Python自学笔记八、进程及线程

一、线程适用IO密集型
进程适用计算密集型
GIL锁决定了python的一个进程中只能有一个线程能被cpu调度。
二、使用线程
1，创建线程
import threading
t=threading.Thread(target=func,args=(xx,xx,))
t.start()
t2=threading.Thread(target=func,args=(xx,xx,))
t2.start()
t3=threading.Thread(target=func,args=(xx,xx,))
t3.start()
主线程挂起状态，当子线程结束任务时，主线程关闭。

2，主线程是否等待子线程
t.setDaemon(False)默认情况下是False，主线程处于挂起状态（夯住了），这种情况下是等待子线程的结束任务再关闭主线程。
在t.start()前加上t.setDaemon可以在主线程结束时，直接关闭主线程，而不等待子线程，不会夯住。

3.主线程等待子线程的执行。
在t.start()后加上t.join()表示执行完t线程后再执行t2线程，join内可以传入参数，表示最多等待该线程执行的时间。

4.event
python线程的事件(event)用于主线程控制其他线程的执行，事件主要设置了三个方法:wait,set,clear.
事件处理的机制：全局定义一个Flag,如果’flag’值为false，那么当程序执行event.wait()方法时就会阻塞，若果为true,那么event.wait方法会释放。
clear:将’flag’设置为false。
set:将’flag’True。

import threadingdef do(event):    print 'start'    event.wait()#红绿灯    print 'execute'event_obj=threading.Event()if __name__=='__main__':    for i in range(10):        t=threading.Thread(target=do,args=(event_obj,))        t.start()    event_obj.clear()#设置为false    inp=raw_input('input:')    if inp=='true':        event_obj.set()#设置为true

5.线程池

三Queue，队列保证线程的有效执行，不会因为爆发式增长的任务而使线程崩溃。
Queue:
最大个数
get,等
get_nowait，不等

四。进程
1.创建进程

import multiprocessingdef f1(a1):    print a1if __name__=='__main__':    t=multiprocessing.Process(target=f1,args=(11,))    t.start()    t1=multiprocessing.Process(target=f1,args=(22,))    t1.start()    print 'end'

2.同线程一样，进程的daemon（默认False)主进程结束后处于夯住状态，子进程继续进行，子进程完成后，主进程关闭。
daemon设置为True时，主进程结束任务后，直接关闭主进程。

3.join，当前进程执行完再执行下一个进程，可以设置等待时间。

import multiprocessingimport timedef f1(a1):    time.sleep(5)    print a1if __name__=='__main__':    t=multiprocessing.Process(target=f1,args=(11,))    t.start()    t.join()    t1=multiprocessing.Process(target=f1,args=(22,))    t1.start()    t1.join()    print 'end'

4.manage.dict可以让不同进程间的数据共同写入

import multiprocessingfrom multiprocessing import Process,Managerimport timedef foo(i,dic):    time.sleep(5)    dic[i]=100+i    for k,v in dic.items():        print (k,v)if __name__=='__main__':    manage=Manager()    dic=manage.dict()    for i in range(10):        p=multiprocessing.Process(target=foo,args=(i,dic,))        p.start()        p.join()

5.进程池

from multiprocessing import Process,Poolimport timedef foo(i):    time.sleep(2)    return i+100#执行结果返回给Bardef Bar(arg):    print argpool=Pool(5)#并不会马上创建5个进程池，只是限制进程量#print pool.apply(Foo,(1,))#每一个任务都是排队进行#print pool.apply_async(func=foo,args=(1,)).get()#每一个任务都是并发执行，可设置回调函数for i in range(10):    pool.apply_async(func=foo,args=(i,),callback=Bar)#foo执行，如果成功执行了foo，那么返回一个值给Bar方法，这里的Bar称为回调函数。print 'end'pool.close()pool.join()#进程池中进程执行完毕后再关闭

6，线程池

import Queueimport threadingclass ThreadPool(object):    def __init__(self,max_num=20):        self.queue=Queue.Queue(max_num) #创建一个最大长度为20的队列        for i in xrange(max_num):            self.queue.put(threading.Thread) #队列里的每一个位置放置一个类名，共同指向同一个内存地址，内只有一个    def get_thread(self):        return self.queue.get()    def add_thread(self):        self.queue.put(threading.Thread)def func(pool,x):       time.sleep(1)    pirnt (x)    pool.add_thread p=ThreadPool(10)#线程池最多10个线程for i in range(10):    ret=p.get_thread() #threading.Thread    ret(target=func,args=(p,i))    t.start()