《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]

由于没有用到锁，所以打印的时候乱七八糟。。。