进程和线程

共享变量规则：

　　空闲让进，忙则等待，有限等待，让权等待。

fork 进程：

#!/usr/bin/env python
#-*-coding:utf-8-*-

#fork:子进程和父进程之间的交互
#父进程可以检查子进程是否完成，但是无法知道其完成的进度。

import os
import time

p=os.fork()

if p:
    print os.wait()
    print "Num"

    
else:
    time.sleep(3)
    print "step 1"
    time.sleep(3)
    print "step2"
    exit()

缺点：如果我想用子进程获得一段数据，返回给父进程

如：

#fork:子进程和父进程之间的交互
#父进程可以检查子进程是否完成，但是无法知道其完成的进度。

import os
import time

p=os.fork()
a='test string'

if p:
    print os.wait()
    print a
    print "Num"
    

    
else:
    time.sleep(3)
    a="I'm good students!"
    print a
    exit()

父进程和子进程依赖的不是同一个内存空间。

 subprocess:

import subprocess
import os
import time

#字符串形式
# rc=subprocess.call(['ls','-l'])
#列表形式
# out = subprocess.call("ls -l", shell=True)
# out = subprocess.call("cd ..", shell=True)

#调用系统shell
#os.system("ls -l")

child = subprocess.Popen(["ping","-c","5","www.google.com"])
#父进程执行
time.sleep(1)   
print  "hello?"

#父进程等待子进程结束后执行
child.wait()     
print("parent process")
print child.pid


#child.poll()           # 检查子进程状态
#child.kill()           # 终止子进程
#child.send_signal()    # 向子进程发送信号
#child.terminate()      # 终止子进程

将子进程的结果输出到文本中：

import subprocess
import os
import time

fp=open('new.txt','w')
out=subprocess.Popen(['ping','-c','5','www.baidu.com'],stdin=subprocess.PIPE,stdout=fp)
out.wait()

将子进程的结果提交给父进程：

import subprocess
import os
import time

out=subprocess.Popen(['ping','-c','5','www.baidu.com'],stdin=subprocess.PIPE,stdout=subprocess.PIPE)

print out.communicate()

用父进程控制子进程让其等待：

import subprocess
import os
import time

import subprocess
child = subprocess.Popen(["cat"], stdin=subprocess.PIPE)
time.sleep(4)
#我们启动子进程之后，cat会等待输入，直到我们用communicate()输入"vamei"。
child.communicate("vamei")

信号量（不太明白）：

import signal
# Define signal handler function
def myHandler(signum, frame):
    print("Now, it's the time")
    exit()

# register signal.SIGALRM's handler 
signal.signal(signal.SIGALRM, myHandler)
signal.alarm(5)
while True:
    print('not yet')

 线程：

#!/usr/bin/env python
#!-*-coding:UTF8-*-
from threading import Thread
import time
def func():
    print 'Thread Start:'
    for i in range(10):
        time.sleep(1)
        print i

for i in range(5):
    t=Thread(target=func,name='1')
    t.start()
    t.join() #阻塞线程，此线程结束后才往后执行。

import threading
import time
import os

# This function could be any function to do other chores.
def doChore():
    time.sleep(0.5)

# Function for each thread
def booth(tid):
    global i
    global lock
    while True:
        lock.acquire()                # Lock; or wait if other thread is holding the lock
        if i != 0:
            i = i - 1                 # Sell tickets
            print(tid,':now left:',i) # Tickets left
            doChore()                 # Other critical operations
        else:
            print("Thread_id",tid," No more tickets")
            os._exit(0)              # Exit the whole process immediately
        lock.release()               # Unblock
        doChore()                    # Non-critical operations

# Start of the main function
i    = 100                           # Available ticket number 
lock = threading.Lock()              # Lock (i.e., mutex)

# Start 10 threads
for k in range(10):
    new_thread = threading.Thread(target=booth,args=(k,))   # Set up thread; target: the callable (function) to be run, args: the argument for the callable 
    new_thread.start()                                      # run the thread

线程OPP：

#!/usr/bin/env python
#!-*-coding:UTF8-*-
from threading import Thread
import time
def func():
    print 'Thread Start:'
    for i in range(10):
        time.sleep(1)
        print i

class TestThread(Thread):
    def __init__(self,**kwargs):
        Thread.__init__(self,**kwargs)
        
    def run(self):
        Thread.run(self)

t=TestThread(target=func,name='aa')
t.start()
t.join()

 线程锁

#!/usr/bin/env python
#!-*-coding:UTF8-*-
import time,threading

class Counter:
    def __init__(self):
        self.value=0
        self.lock=threading.Lock()
    def  increament(self):
        self.lock.acquire()
        self.value=self.value+1
        self.lock.release()
        return self.value

counter=Counter()

class TestThread(threading.Thread):
    def run(self):
        time.sleep(1)
        print counter.increament()
        

         
for i in range(100):
    t=TestThread(None)
    t.start()

print 'haha'

import threading
import time
import os

# This function could be any function to do other chores.
def doChore():
    time.sleep(0.5)

# Function for each thread
class BoothThread(threading.Thread):
    def __init__(self,tid,monitor):
        self.tid=tid
        self.monitor=monitor
        threading.Thread.__init__(self)
    
    def run(self):
        while True:
            monitor['lock'].acquire()
            if monitor['tick']>0:
                print (self.tid,monitor['tick'])
                monitor['tick']-=1
                
                doChore()
            else:
                print "ticket is sell out"
                os._exit(0)
            monitor['lock'].release()
            doChore()
        
        
# Start of the main function
monitor = {'tick':100, 'lock':threading.Lock()}

# Start 10 threads
for k in range(10):
    new_thread= BoothThread(k, monitor)
    new_thread.start()
    

#!/usr/bin/env python
#!-*-coding:UTF8-*-
import time,threading
from _ast import Num
from multiprocessing import Condition

class Goods:
    def __init__(self):
        self.count=6
    def produce(self,num=1):
        self .count=self.count+num
        print "生产了一个商品",self.count
    def consume(self,num=1):
        if(self.count<0):
            return 
        self.count=self.count-num
        print "消费了一个商品",self.count
       

class Producer(threading.Thread):
    def __init__(self,codition,goods):
        threading.Thread.__init__(self)
        self.goods=goods
        self.condition=codition
    def run(self):
        while True:
            self.condition.acquire()
            goods.produce(1)
            self.condition.notify_all()
            self.condition.release()
            time.sleep(4) #4秒生产一个商品、
            
class Consumer(threading.Thread):
    def __init__(self,condition,goods):
        self.cond=condition
        self.goods=goods
        threading.Thread.__init__(self)    
    def run(self):
        self.cond.acquire()
        if self.goods.count<=0:
            self.cond.wait()
        goods.consume(1)
        self.cond.release()
        time.sleep(1)
        
cond=Condition()
goods=Goods()
producer=Producer(cond,goods)
producer.start()

for i in range(10):
    consumer=Consumer(cond,goods)
    consumer.start()
    consumer.join()

print "end-----"

         

 简单线程

#!/usr/bin/env python
# !-*-coding:utf-8-*-
import threading
import time

class MyThread(threading.Thread):
    def __init__(self,func,*args):
        threading.Thread.__init__(self)
        self.func =func
        self.args = args

    def run(self):
        print "starting--------->"
        self.func(self.args)
        print "end!!!"

def func(a):
    time.sleep(4)
    print "ajhaa", a

th1 = MyThread(func, "dsfasdfasdf")
th1.start()
th2 = MyThread(func, "dsfasdfasdf")
th2.start()
th3 = MyThread(func, "dsfasdfasdf")
th3.start()