18.1 引言/动机
18.2 线程和进程
18.2.1 什么是进程(重量级进程)?
计算机程序只不过是磁盘中可执行的,二进制(或其他类型)的数据,他们只有在被读取到内存中,被操作系统调用时才开始他们的生命期,进程是程序的一次执行,每个进程都有自己的地址空间,内存,数据栈以及其他记录其运行轨迹的赋值数据,操作系统管理在其上运行的所有进程,并为这些进程公平地分配时间,进程可以通过fork和spawn操作来完成其他任务,其之间用进程间通讯(IPC)
18.2.2 什么是线程(轻量级进程)?
线程跟进程有些相似,不同的是,所有线程运行在同一个进程中,共享相同运行环境,他们可以想象成是在主进程或"主线程"中并行运行的"迷你进程".
一个进程中的各个线程之间共享同一片数据空间,从而更方便的共享数据和相互通讯,线程一般都是并行执行.
18.3 Python,线程和全局解释器锁
18.3.1 全局解释器锁(GIL)
Python代码的执行由Python虚拟机(也叫解释器主循环)来控制,对虚拟机的访问由卷曲解释器锁(GIL)来控制,正式这个锁能保证同一时刻只有一个线程在运行
在多线程环境中,Python虚拟机按一下方式执行:
1.设置GIL
2.切换到一个线程去运行
3.运行:1.执行数量的字节码指令 或2.线程主动让出控制(调用time.sleep(0))
4.把线程设置为睡眠状态
5.解锁GIL
6.再次重复以上所有步骤
18.3.2 退出线程
当一个线程结束计算,它就退出了,线程可以调用thread.exit()之类的退出函数.或标准的sys.exit()或抛出一个SystemExit异常等,不过你不可以直接杀掉一个线程
主线程应该是一个好的管理者,它了解每个线程都做些什么事,线程都需要什么数据和参数,以及在线程结束的时候,他们提供了什么结果,这样主线程就可以把各个线程的结果组成一个有意义的最后结果.
18.3.3 在Python中使用线程
在解释器里判断线程是否可用,只要导入thread模块后未报错即表示线程可用
>>> import thread
>>>
18.3.4 没有线程支持的情况
例,单线程中运行的循环()
在单线程中顺序执行两个循环,一定要一个循环结束,另一个才能开始,总时间是各个循环运行时间之和
# vi onethr.py
-----------------------------------------
#!/usr/bin/env python
from time import sleep,ctime
def loop0():
print 'start loop 0 at:',ctime()
sleep(4)
print 'loop 0 done at:',ctime()
def loop1():
print 'start loop 1 at:',ctime()
sleep(2)
print 'loop 1 done at:',ctime()
def main():
print 'starting at:',ctime()
loop0()
loop1()
print 'all DONE at:', ctime()
if __name__ == '__main__':
main()
-----------------------------------------
输出:
# python onethr.py
starting at: Wed Dec 4 07:01:26 2013
start loop 0 at: Wed Dec 4 07:01:26 2013
loop 0 done at: Wed Dec 4 07:01:30 2013
start loop 1 at: Wed Dec 4 07:01:30 2013
loop 1 done at: Wed Dec 4 07:01:32 2013
all DONE at: Wed Dec 4 07:01:32 2013
假定loop0()和loop1()例做的不是睡眠,而是各自独立,不相关的运算,各自运算结果到最后将汇总成一个最终的结果
18.3.5 Python的threading模块
Python提供了thread,threading和Queue等多线程编程模块
注:避免使用thread模块
因为使用thread模块里的属性有可能会与threading出现冲突,threading较thread对线程支持更加完善'
18.4 thread模块
thread模块和锁对象
函数描述
thread模块函数
start_new_thread(function,
args, kwargs=None)产生一个新的进程,在新线程中用指定的参数和可选kwargs来调用这个函数
allocate_lock()分配一个LookType类型的锁对象
exit()让线程退出
LockType类型锁对象方法
acquire(wait=None)尝试获得锁对象
locked()如果获取了锁对象返回True,否则返回False
release()释放锁
例,这儿执行的是和onethr.py中一样的循环,不同的是,这次我们使用的是thread模块提供的简单的多线程机制,两个循环
# vi mtsleep1.py
------------------------------
#!/usr/bin/env python
import thread
from time import sleep,ctime
def loop0():
print 'start loop 0 at:', ctime()
sleep(4)
print 'loop 0 done at:',ctime()
def loop1():
print 'start loop 1 at:', ctime()
sleep(2)
print 'loop 1 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()
-------------------------------
这个程序的输出与之前的输出大不相同,之前是运行了6,7秒,现在是4秒
因为睡眠4秒和2秒的代码现在是并发执行的,这样就使得运行时间被缩短了
在这里,我们使用了sleep()函数作为我们的同步机制
# python mtsleep1.py
-----------------------------------------
starting at: Fri Dec 20 23:56:42 2013
start loop 1 at: Fri Dec 20 23:56:42 2013
start loop 0 at: Fri Dec 20 23:56:42 2013
loop 1 done at: Fri Dec 20 23:56:44 2013
loop 0 done at: Fri Dec 20 23:56:46 2013
all DONE at: Fri Dec 20 23:56:48 2013
------------------------------------------
例,通过使用锁来完成任务
这里,使用锁比mtsleep1.py那里在主线程中使用sleep()函数更合理
# vi mtsleep2.py
------------------------------------
#!/usr/bin/env python
import thread
from time import sleep,ctime
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()
------------------------------------
# python mtsleep2.py
---------------------------
starting at: Sat Dec 21 01:13:06 2013
start loop 1 at: Sat Dec 21 01:13:06 2013
start loop 0 at: Sat Dec 21 01:13:06 2013
loop 1 done at: Sat Dec 21 01:13:08 2013
loop 0 done at: Sat Dec 21 01:13:10 2013
all DONE at: Sat Dec 21 01:13:10 2013
---------------------------
在线程结束时,线程要自己去做解锁操作,最后一个循环只是坐在那一直等,直到两个锁都被解锁为止才继续运行,由于我们顺序检查每一个锁,所以我们可能会要长时间地等待运行时间长且放在前面的线程,当这些线程的锁释放后,后面的锁可能早就释放了,结果主线程只能毫不停歇地完成对后面这些锁的检查
thread模块只是作为演示,在使用多线程程序应该使用更高级别的模块,如threading等
18.5 threading模块
接下来,我们要介绍的是更高级别的threading模块,他不仅提供了Thread类,还提供了各种非常好用的同步机制
这里我们不在提到锁原语,而Thread类也有某种同步机制
threading模块对象
threading模块对象描述
Thread标识一个线程的执行对象
RLock锁原语对象(跟thread模块里的锁对象相同)
Condition条件变量对象能让一个线程停下来,等待其他线程满足了某个条件,如,状态的改变或值的改变
Event通用的条件变量,多个线程可以等待某个事件的发生,在事件发生后,所有的线程都会被激活.
Semaphore为等待锁的线程提供一个类似"等候室"的结构
BoundedSemaphore与Semaphpre类似,只是它不允许超过初始值
Timer与Thread相似,只是,它要等待一段时间后才开始运行.
核心提示:守护线程
守护线程一般是一个等待客户请求的服务器,如果没有客户提出请求,它就在那等着,如果你设定一个线程为守护线程,就标识你在说这个线程是不重要的,在进程退出的时候,不用等待这个线程退出
如果你的主线程要退出的时候,不用等待那些子线程完成,那就设定这些线程的daemon属性
如果你想要等待子线程完成再退出,那就什么都不用做
整个Python会在所有的非守护线程退出后才会结束,即进程中没有非守护线程存在的时候才结束
18.5.1 Thread类
用Thread类,你可以用多种方法来创建线程:
1.创建一个Thread的实例,传给它一个函数
2.创建一个Thread的实例,传给它一个可调用的类对象
3.从Thread派生出一个子类,创建一个这个子类的实例
函数描述
start()开始线程的执行
run()定义线程的功能的函数(一般会北子类重写)
join(timeout=None)程序挂起,直到线程结束:如果给了timeout,则最多阻塞timeout秒
getName()返回线程的名字
setName(name)设置线程的名字
isAlive()布尔标志,标识这个线程是否还在运行中
isDaemon()返回线程的daemon标志
setDaemon(daemonic)把线程的daemon标志设为daemonic
创建一个Thread的实例,传给它一个函数
例,使用thread模块,threading模块的Thread类有一个join()函数,允许主线程等待线程的结束
# vi mtsleep3.py
-------------------------------
#!/usr/bin/env python
import threading
from time import sleep,ctime
loops = [4,2]
def loop(nloop,nsec):
print 'start loop', nloop, 'at:', ctime()
#!/usr/bin/env python
import threading
from time import sleep,ctime
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:
t = threading.Thread(target=loop,args=(i,loops[i]))
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()
-------------------------------
# python mtsleep3.py
-------------------------------
starting at: Sat Dec 21 12:14:57 2013
start loop 0 at: Sat Dec 21 12:14:57 2013
start loop 1 at: Sat Dec 21 12:14:57 2013
loop 1 done at: Sat Dec 21 12:14:59 2013
loop 0 done at: Sat Dec 21 12:15:01 2013
all DONE at: Sat Dec 21 12:15:01 2013
--------------------------------
所有线程都创建了之后,再一起调用start()函数启动,而不是创建一个启动一个,而且不用再管理一堆锁,只要简单对每个线程调用join()函数就可以
创建一个Thread实例,传给它一个可调用的类对象
此例中,我们传了一个可调用的类的实例,而不是仅传一个函数,相对mtsleep3.py中的方法来说,这样做更具面向对象的概念
# vi mtsleep4.py
------------------------------
#!/usr/bin/env python
import threading
from time import sleep,ctime
loops = [4,2]
class ThreadFunc(object):
def __init__(self,func,args,name=''):
self.name = name
self.func = func
self.args = args
def __call__(self):
apply(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:
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()
------------------------------
# python mtsleep4.py
---------------------------
starting at: Sat Dec 21 18:51:07 2013
start loop 0 at: Sat Dec 21 18:51:07 2013
start loop 1 at: Sat Dec 21 18:51:07 2013
loop 1 done at: Sat Dec 21 18:51:09 2013
loop 0 done at: Sat Dec 21 18:51:11 2013
all DONE at: Sat Dec 21 18:51:11 2013
----------------------------
18.5.4 斐波那契,阶乘和累加和
从Thread派生出一个子类,创建一个这个子类的实例
例,我们现在要子类化Thread类,而不是创建它的实例
# vi mtsleep5.py
-------------------------------
#!/usr/bin/env python
import threading
from time import sleep, time, ctime
loops = [ 4, 2 ]
class MyThread(threading.Thread):
'''
MyThread derives from the threading.Thread baseclass.
Rather than a callable class, the run() method is
automatically invoked when the thread begins execution.
'''
# constructor
def __init__(self, func, args, name=''):
threading.Thread.__init__(self)
self.name = name
self.setFunc(func, args)
def setFunc(self, func, args):
'''
setFunc() is the method that sets the function
to be called as well as its arguments
'''
self.func = func
self.args = args
def getResult(self):
'''
getResult() provides the return value
from the function call
'''
return self.res
def run(self):
'''
save the return value from the function call
into an instance var rather than returning it
'''
# * 1.6 * self.res = self.func(*self.args)
self.res = apply(self.func, self.args)
# loop() is the same as before
def loop(nloop, nsec):
print 'start loop', nloop, 'at:', ctime(time())
sleep(nsec)
print 'loop', nloop, 'done at:', ctime(time())
def main():
# variable setup
print 'starting threads...'
threads = []
nloops = range(len(loops))
# allocate (but do not start) threads
for i in nloops:
t = MyThread(loop, (i, loops[i]), loop.__name__)
threads.append(t)
# start threads
for i in nloops:
threads[i].start()
# wait for all threads to complete
for i in nloops:
threads[i].join()
print 'all DONE'
if __name__ == '__main__':
main()
-------------------------------
# python mtsleep5.py
------------------------------
starting threads...
start loop 0 at: Sat Dec 21 23:44:07 2013
start loop 1 at: Sat Dec 21 23:44:07 2013
loop 1 done at: Sat Dec 21 23:44:09 2013
loop 0 done at: Sat Dec 21 23:44:11 2013
all DONE
-----------------------------
为了让mtsleep5.py中,Thread的子类更为通用,我们把子类单独放在一个模块中,加上一个getResult()函数用以返回函数的运行结果
例,myThread子类化Thread
# vi myThread.py
------------------------------------
#!/usr/bin/env python
import threading
from time import time, ctime
class MyThread(threading.Thread):
def __init__(self, func, args, name=''):
threading.Thread.__init__(self)
self.name = name
self.func = func
self.args = args
def getResult(self):
return self.res
def run(self):
print 'starting', self.name, 'at:', \
ctime()
self.res = apply(self.func, self.args)
print self.name, 'finished at:', \
ctime()
------------------------------------
例,斐波那契,阶乘和累加和
在这个多线程程序中,我们会分别在单线程和多线程环境中,运行三个递归函数
# vi mtfacfib.py
------------------------------
#!/usr/bin/env python
from myThread import MyThread
from time import time, ctime, sleep
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 sum(x):
sleep(0.1)
if x < 2: return 1
return (x + sum(x-1))
funcs = (fib, fac, sum)
n = 12
def main():
nfuncs = range(len(funcs))
print '*** SINGLE THREAD'
for i in nfuncs:
print 'starting', funcs[i].__name__, \
'at:', ctime(time())
print funcs[i](n)
print funcs[i].__name__, 'finished at:', \
ctime(time())
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 at:', ctime(time())
if __name__ == '__main__':
main()
------------------------------
# python mtfacfib.py
-----------------------------------------
*** SINGLE THREAD
starting fib at: Sat Dec 21 23:55:31 2013
233
fib finished at: Sat Dec 21 23:55:34 2013
starting fac at: Sat Dec 21 23:55:34 2013
479001600
fac finished at: Sat Dec 21 23:55:35 2013
starting sum at: Sat Dec 21 23:55:35 2013
78
sum finished at: Sat Dec 21 23:55:37 2013
*** MULTIPLE THREADS
starting fib at: Sat Dec 21 23:55:37 2013
starting fac at: Sat Dec 21 23:55:37 2013
starting sum at: Sat Dec 21 23:55:37 2013
fac finished at: Sat Dec 21 23:55:38 2013
sum finished at: Sat Dec 21 23:55:38 2013
fib finished at: Sat Dec 21 23:55:39 2013
233
479001600
78
all DONE at: Sat Dec 21 23:55:39 2013
------------------------------------------
18.5.5 threading模块中的其他函数
函数描述
activeCount()当前活动的线程对象的数量
currentThread()返回当前线程对象
enumerate()返回当前活动线程的列表
settrace(func)为所有线程设置一个跟踪函数
setprofile(func) 为所有线程设置一个profile函数
18.5.5 生产者-消费者问题和Queue模块
这个实现中使用了Queue对象和随机地生产(和消耗)货物的方式,生产者和消费者相互独立并且并发的运行
# vi prodcons.py
----------------------------------
#!/usr/bin/env python
from random import randint
from time import time, ctime, sleep
from Queue import Queue
from myThread import MyThread
def writeQ(queue):
print 'producing object for Q...',
queue.put('xxx', 1)
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)
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()
----------------------------------
# python prodcons.py
-----------------------------------------
starting writer at: Sun Dec 22 00:00:36 2013
producing object for Q... size now 1
starting reader at: Sun Dec 22 00:00:36 2013
consumed object from Q... size now 0
producing object for Q... size now 1
consumed object from Q... size now 0
producing object for Q... size now 1
consumed object from Q... size now 0
writer finished at: Sun Dec 22 00:00:42 2013
reader finished at: Sun Dec 22 00:00:46 2013
all DONE
-------------------------------------------
本例中,一个要完成多项任务的程序,可以考虑没有任务使用一个线程,这样的程序在设计上相对于单线程做所有事的程序来说,更为清晰
18.6 相关模块
模块描述
thread基本的,底级别的线程模块
threading高级别的线程和同步对象
Queue供多线程使用的同步先进先出(FIFO)队列
mutex互斥对象
SocketServer具有线程控制的TCP和UDP管理