《python核心编程》读书笔记--第18章 多线程编程
18.1引言
在多线程（multithreaded，MT）出现之前，电脑程序的运行由一个执行序列组成。多线程对某些任务来说是最理想的。这些任务有以下特点：它们本质上就是异步的，需要多个并发事务，各个事务的运行顺序可以是不确定的、随机的、不可预测的。这样的编程任务可以被分成多个执行流，每个流都有一个要完成的目标。根据应用的不同，这些子任务可能都要计算出一个中间结果，用于合并得到最后的结果。运算密集型任务一般都比较容易分割为多个子任务。
由于顺序执行的程序只有一个线程在运行，它要保证做多个任务，并且不会有某个任务占用太多时间。执行多任务的顺序执行的程序一般程序控制流程都很复杂，难以理解。
使用多线程编程和一个共享的数据结构比如Queue，这种程序任务可以用几个功能单一的线程来组织。
18.2线程和进程
进程
进程是程序的一次执行。每个进程都有自己的地址空间、内存、数据栈及其他记录其运行轨迹的辅助数据。进程都有自己的内存空间、数据栈等，所以只能使用进程间通讯（interprocess communication,IPC），而不能直接共享信息。
线程
线程跟进程类似，不同的是，所有的线程运行在同一个进程中，共享相同的运行环境。一个进程的各个线程之间共享一片数据空间，所以线程之间可以比进程之间更方便地共享数据以及相互通讯。但是也有副作用，就是同一片数据，在多个线程访问顺序不同时，可能导致数据不一致问题，当然这是可以解决的。
18.3Python、线程和全局解释器锁
1、全局解释器锁（GIL）
Python代码的执行由Python虚拟机（也称解释器主循环）控制。在一个主循环中，只有一个线程在执行，与单核CPU类似，虽然Python解释器可以运行“多个”线程，但是在任意时刻，只有一个线程在解释器中运行。
以上原理由全局解释器锁（GIL）控制，保证同一时刻只有一个线程在运行。在多线程环境中，Python虚拟机按以下方式执行。
1）设置GIL
2）切换到一个线程去运行
3）运行：
a.指定数量自己码的指令，或者
b.线程主动让出控制（time.sleep()）
4）把线程设置为睡眠状态
5）解锁GIL
6）再次重复以上所有步骤。
调用外部扩展（c程序等）时，GIL被锁定，直到这个函数结束为止。
2、退出线程
当一个线程结束计算，就退出了。线程可以调用thread.exit()之类的退出函数，也可以用python退出的标准方法，如sys.exit()或者抛出一个SystemExit异常等。不过不可以直接kill一个线程。
thread和threading两个模块进行进程、线程管理，作者建议不用thread，一个很明显的原因是：thread模块主线程退出时，所有其他线程没有被清除就退出了；threading就能确保所有“重要”的子线程都退出后，程序才会结束。
3、下面看一下单线程
#-*- coding:utf-8 -*- from time import sleep,ctime def loop0(): print 'start loop0 at:',ctime() sleep(4) print 'loop0 done at:',ctime() def loop1(): print 'start loop1 at:',ctime() sleep(2) print 'loop1 done at:',ctime() def main(): print 'starting at:',ctime() loop0() loop1() print 'all DONE at:',ctime() if __name__ == '__main__': main()
当第一个循环执行完之后才会继续执行第二个循环。
4、模块
python提供的几个多线程编程模块，包括thread、threading、Queue等。thread和threading允许我们创建和管理线程。thread提供了基本的线程和锁的支持，而threading提供了更高级别，功能更强的线程管理功能。Queue允许用户创建可以用于多个线程之间共享数据的队列数据结构。
作者再次强调不用thread而是用threading。
18.4Thread模块
两个例子
#-*- coding:utf-8 -*- from time import sleep,ctime import thread def loop0(): print 'start loop0 at:',ctime() sleep(4) print 'loop0 done at:',ctime() def loop1(): print 'start loop1 at:',ctime() sleep(2) print 'loop1 done at:',ctime() def main(): print 'starting at:',ctime() thread.start_new_thread(loop0,()) thread.start_new_thread(loop1,()) #这个语句是必须有的，主线程必须等待前面两个线程运行完以后再执行最后一句 #然而这样的后果就是：对于单线程，运行时间并不减少；可能不知道每个线程运行多长时间 sleep(6) print 'all DONE at:',ctime() if __name__ == '__main__': main()
上面问题的解决方法就是引进锁。
#-*- coding:utf-8 -*- from time import sleep,ctime import thread loops = [4,2] def loop(nloop,nsec,lock): print 'start loop',nloop,' at:',ctime() sleep(nsec) print 'loop',nloop,' done at:',ctime() lock.release() #一个线程运行结束后释放，通知主线程已经结束 def main(): print 'starting at:',ctime() locks = [] nloops = range(len(loops)) #下面获得锁和执行线程需要分开，不写在一个循环里面，因为： #要让所有线程同时开始运行；获得锁需要时间，如果有的退出太快，还没获得锁线程就结束了 for i in nloops: lock = thread.allocate_lock() #分配一个锁对象 lock.acquire() #获取锁对象，表示把锁锁上 locks.append(lock) #锁列表 for i in nloops: #下面的第二个参数必须有，是一个元组 thread.start_new_thread(loop,(i,loops[i],locks[i])) #最后一个循环用来检查是否所有锁都释放了,其实并没有什么用 for i in nloops: while locks[i].locked(): pass print 'all DONE at:',ctime() if __name__ == '__main__': main()
18.5Threading模块
threading模块中将提供Thread类来实现多线程，并且提供了很好的同步机制。thread模块不支持守护线程，即主线程退出时，不管是否有子线程，都会被强行退出。而threading模块有机制来避免上面的问题。
1、thread类
利用thread类可以有多种方法来创建线程。有三种方法：
- 创建一个Thread类的实例，传给它一个函数
- 创建一个Thread类的实例，传给它一个可调用的类的对象
- 从Thread派生出一个子类，创建一个这个子类的实例
作者推荐最后一种。
第一个例子
实例化一个Thread类，传入一个函数。
#-*- coding:utf-8 -*- from time import sleep,ctime import threading loops = [4,2] def loop(nloop,nsec): print 'start loop',nloop,' at:',ctime() sleep(nsec) print 'loop',nloop,' done at:',ctime() def main(): print 'starting at:',ctime() threads = [] nloops = range(len(loops)) for i in nloops: #下面实例化Thread类，实例化之后并不马上开始（直到调用start），这样可以更好的同步 t = threading.Thread(target = loop,args = (i,loops[i])) threads.append(t) for i in nloops: threads[i].start() for i in nloops: #线程挂起，直到运行结束 #调用join另一个重要的方面就是它可以完全不用调用，一旦线程启动就会一直运行知道结束 #如果主线程有其他事情做（不止是等待结束），就不用调用join，只有等待结束时才调用join threads[i].join() print 'all DONE at:',ctime() if __name__ == '__main__': main()
第二个例子
创建一个Thread的实例，传给它一个可调用的类对象。
#-*- coding:utf-8 -*- from time import sleep,ctime import threading loops = [4,2] class ThreadFunc(object): """docstring for THreadFunc""" def __init__(self, func,args,name = ''): super(ThreadFunc, self).__init__() self.name = name self.func = func self.args = args #为了可以使Thread调用，需要定义call函数，用来执行func函数 def __call__(self): self.func(*self.args) def loop(nloop,nsec): print 'start loop',nloop,' at:',ctime() sleep(nsec) print 'loop',nloop,' done at:',ctime() def main(): print 'starting at:',ctime() threads = [] nloops = range(len(loops)) for i in nloops: #下面实例化Thread类，接收的是一个类实例 t = threading.Thread(target = ThreadFunc(loop,(i,loops[i]),loop.__name__)) threads.append(t) for i in nloops: threads[i].start() for i in nloops: threads[i].join() print 'all DONE at:',ctime() if __name__ == '__main__': main()
第三个例子
创建一个Thread 的实例，传给它一个可调用的类对象。
#-*- coding:utf-8 -*- from time import sleep,ctime import threading loops = (4,2) #print dir(threading.Thread) 查看threading.Thread类中的方法，有run class MyThread(threading.Thread): """docstring for THreadFunc""" def __init__(self, func,args,name = ''): super(MyThread, self).__init__() self.name = name self.func = func self.args = args #注意这里的run函数重新定义 def run(self): self.func(*self.args) def loop(nloop,nsec): print 'start loop',nloop,' at:',ctime() sleep(nsec) print 'loop',nloop,' done at:',ctime() def main(): print 'starting at:',ctime() threads = [] nloops = range(len(loops)) for i in nloops: #下面实例化MyThread类 t = MyThread(loop,(i,loops[i]),loop.__name__) threads.append(t) for i in nloops: threads[i].start() for i in nloops: threads[i].join() print 'all DONE at:',ctime() if __name__ == '__main__': main()
看上面的三个例子，确实感觉第三个更灵活和方便。但是话说回来，本质上还是第一个例子的灵魂加上类的外衣。
下面是一个斐波那契数列的例子。比较单线程和多线程的区别。
先自定义一个MyThread类：
#-*- coding:utf-8 -*- from time import sleep,ctime import threading class MyThread(threading.Thread): """docstring for THreadFunc""" def __init__(self, func,args,name = ''): super(MyThread, self).__init__() self.name = name self.func = func self.args = args def getResult(self): return self.res #注意这里的run函数重新定义 def run(self): print 'starting',self.name,'at:',ctime() self.res = self.func(*self.args) print self.name,'finished at:',ctime()
下面是三个数值例子。
#-*- coding:utf-8 -*- from time import sleep,ctime from myThread import MyThread #Fibonacci数列 def fib(x): sleep(0.005) if x < 2:return 1 return (fib(x-2) + fib(x-1)) #阶乘 def fac(x): sleep(0.1) if x < 2:return 1 return (x * fac(x-1)) #累加和 def summ(x): sleep(0.1) if x < 2:return 1 return (x + summ(x-1)) funcs = [fib,fac,summ] n = 12 def main(): nfuncs = range(len(funcs)) print '*** SINGLE THREAD' for i in nfuncs: print 'starting',funcs[i].__name__,'at:',ctime() print funcs[i](n) print funcs[i].__name__,'finished at:',ctime() print '\n*** MULTIPLE THREADS' threads = [] for i in nfuncs: t = MyThread(funcs[i],(n,),funcs[i].__name__) threads.append(t) for i in nfuncs: threads[i].start() for i in nfuncs: threads[i].join() print threads[i].getResult() print 'all DONE.' if __name__ == '__main__': main()
>>>*** SINGLE THREAD
starting fib at: Thu Feb 25 14:49:18 2016
233
fib finished at: Thu Feb 25 14:49:20 2016
starting fac at: Thu Feb 25 14:49:20 2016
479001600
fac finished at: Thu Feb 25 14:49:21 2016
starting summ at: Thu Feb 25 14:49:21 2016
78
summ finished at: Thu Feb 25 14:49:22 2016
*** MULTIPLE THREADS
starting fib at: Thu Feb 25 14:49:22 2016
starting fac at: Thu Feb 25 14:49:22 2016
starting summ at: Thu Feb 25 14:49:22 2016
facsumm finished at:finished at: Thu Feb 25 14:49:24 2016
Thu Feb 25 14:49:24 2016
fib finished at: Thu Feb 25 14:49:25 2016
233
479001600
78
all DONE.
[Finished in 7.4s]
可以看出，多线程确实节省了一些时间，但是由于MyThread类的构造，打印顺序有点混乱。另，斐波那契数列用递归太耗时，可以看一下这里的最后部分 http://www.cnblogs.com/batteryhp/p/4987261.html。令，上面的几个for可以用in函数直接运行，不用算长度再取下标。
2、生产者-消费者问题和Queue模块
Queue模块用来进行线程间的通讯，让各个线程之间共享数据。
#-*- coding:utf-8 -*- from random import randint from time import sleep from Queue import Queue from myThread import MyThread def writeQ(queue): print 'producing object for Q...',queue.put('xxx',1) #向队列中put进一个 print "size now",queue.qsize() def readQ(queue): val = queue.get(1) #从队列中取出一个 print 'consumed object from Q... size now',queue.qsize() def writer(queue,loops): for i in range(loops): writeQ(queue) sleep(randint(1,3)) def reader(queue,loops): for i in range(loops): readQ(queue) sleep(randint(2,5)) funcs = [writer,reader] nfuncs = range(len(funcs)) def main(): nloops = randint(2,5) q = Queue(32) #定义最大长度为32的队列的同步实现 threads = [] for i in nfuncs: t = MyThread(funcs[i],(q,nloops),funcs[i].__name__) threads.append(t) for i in nfuncs: threads[i].start() for i in nfuncs: threads[i].join() print 'all DONE.' if __name__ == '__main__': main() >>> starting writer at: Thu Feb 25 15:48:39 2016 producing object for Q... None size now 1 starting reader at: Thu Feb 25 15:48:39 2016 consumed object from Q... size now 0 producing object for Q... None size now 1 producing object for Q... None size now 2 consumed object from Q... size now 1 producing object for Q... None size now 2 producing object for Q... None size now 3 consumed object from Q... size now 2 writer finished at: Thu Feb 25 15:48:49 2016 consumed object from Q... size now 1 consumed object from Q... size now 0 reader finished at: Thu Feb 25 15:49:02 2016 all DONE. [Finished in 23.3s]
由于没有用到锁，所以打印的时候乱七八糟。。。
