Thread
先引入一个例子：
>>> from threading import Thread,currentThread,activeCount >>> >>> def test(s): ... print "ident:",currentThread().ident ... print "count:",activeCount() ... print s ... >>> >>> Thread(target = test, args =('Hello',)).start() ident: 1099229504 count: 2 Hello
需要模块threading，对应的帮助文档：
http://docs.python.org/2.7/library/threading.html#module-threading
class threading.Thread(group=None, target=None, name=None, args=(), kwargs={}) This constructor should always be called with keyword arguments. Arguments are: group should be None; reserved for future extension when a ThreadGroup class is implemented. target is the callable object to be invoked by the run() method. Defaults to None, meaning nothing is called. name is the thread name. By default, a unique name is constructed of the form “Thread-N” where N is a small decimal number. args is the argument tuple for the target invocation. Defaults to (). kwargs is a dictionary of keyword arguments for the target invocation. Defaults to {}. If the subclass overrides the constructor, it must make sure to invoke the base class constructor (Thread.__init__()) before doing anything else to the thread.
除了标识符，还可以给线程取个名字，便于调试。
还可以继承Thread实现自己的线程类：
>>> from threading import * >>> >>> class MyThread(Thread): ... def __init__(self,name,*args): ... super(MyThread,self).__init__(name = name)#调用父类的init，设置线程的名称 ... self.data = args ... ... def run(self): ... print self.name,self.data ... >>> >>> MyThread("abc",range(10)).start() abc ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9],)>>> >>> >>> MyThread("abc",range(5)).start() abc ([0, 1, 2, 3, 4],) >>> MyThread("abc",range(10)).start() abc ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9],)
将线程daemon属性设为True，那么表示这是一个背景线程，进程退出时不会等到该线程结束。
调用join()等到线程结束，可提供超时参数（秒，浮点数设定更小粒度）。
isAlive()检查线程状态，join()可以多次调用。
>>> from time import sleep >>> >>> def test(): ... print "__thread__start__" ... sleep(10) ... print "__thread__exit__" ... >>> >>> def run(): ... t = Thread(target = test) ... t.start() ... t.join(2) //设置超时时间为2s ... ... print t.isAlive()//检查线程状态 ... t.join() //再次等待 ... ... print "over!" ... >>> >>> run() __thread__start__ True __thread__exit__ over!
Lock
Lock不支持递归加锁，也就是说即便在同一个线程中，也必须等待锁释放。通常建议改用RLock，它会处理"owning thread"和"recursion level"状态，对于同一个线程的多次请求锁行为，只累加计数器。每次调用release()将递减该计数器，直到0时释放锁，因此acquire()和relase()必须承兑出现，一个加锁，一个释放。
threading中的成员大多实现了上下文协议，尽可能用with代替手工调用。
>>> lock = RLock() >>> >>> def show(i): ... with lock: ... print currentThread().name,i ... sleep(0.1) ... >>> def test(): ... with lock: ... for i in range(5): ... show(i) ... >>> >>> for i in range(2): ... Thread(target = test).start() ... >>> Thread-2 0 Thread-2 1 Thread-2 2 Thread-2 3 Thread-2 4 Thread-3 0 Thread-3 1 Thread-3 2 Thread-3 3 Thread-3 4
所有线程等待lock锁，串行执行。
Event
Event通过一个内部标记来协调多线程运行。方法wait()阻塞线程执行，直到标记为True。
set()将标记设为True，clear()更改标记为False。isSet()用于判断标记状态。
>>> from threading import * >>> >>> def test(): ... e = Event() ... def test(): ... for i in range(5): ... e.wait() ... e.clear() ... print i ... Thread(target = test).start() ... return e ... >>> e = test() >>> e.set() >>> 0 >>> e.set() >>> 1 >>> e.set() >>> 2 >>> e.set() >>> 3
如果不调用clear()，那么标记一直为True,wait()就不会发生堵塞行为。
通常为每个线程准备一个独立的Event，而不是多个线程共享，以避免未及时调用clear(0时发生意外情况。
condition
condition像Lock和Event的综合体，除基本的锁操作外，还提供了类似yield的功能。
在获取锁以后，可以调用wait()临时让出锁，当前线程被阻塞，直到notify()发送通知后再次请求锁来恢复执行。将wait当做yield，那么notify就是send
可以将已有的锁对象传给Condition
>>> from threading import * >>> from time import sleep >>> >>> >>> cond = Condition() >>> >>> def t1(): ... with cond: ... for i in range(5): ... print currentThread().name,i ... sleep(0.1) ... if i == 3:cond.wait() ... >>> >>> def t2(): ... with cond: ... for i in range(5): ... print currentThread().name,i ... sleep(0.1) ... cond.notify() ... >>> >>> Thread(target = t1).start();Thread(target = t2).start() Thread-1 0 >>> Thread-1 1 Thread-1 2 Thread-1 3 //调用wait()，获取锁，当前线程被阻塞 Thread-2 0 Thread-2 1 Thread-2 2 Thread-2 3 Thread-2 4 Thread-1 4//t2执行完range(5)循环，通过cond.notify()发送通知，重新获取锁，继续执行
只有获取锁的线程才能调用wait()和notify()，因此必须在锁释放前调用。
当wait()释放锁后，其他线程也可进入wait状态。notifyAll()激活所有等待线程，让它们去抢锁然后完成后继续执行。
>>> def test(): ... with cond: ... for i in range(5): ... print currentThread().name,i ... sleep(0.1) ... if i == 2:cond.wait() ... >>> >>> Thread(target = test).start();Thread(target = test).start() Thread-3 0 >>> Thread-3 1 Thread-3 2 Thread-4 0 Thread-4 1 Thread-4 2 //Thread-4等待，Thread-3持有锁 >>> with cond:cond.notifyAll() //通知所有cond.wait线程 ... >>> Thread-3 3 //Thread-3和Thread-4再次抢锁完成后继续执行，顺序不定 Thread-3 4 Thread-4 3 Thread-4 4
Semaphore
Semaphore通过一个计数器来限制可同时运行的线程数量。计数器表示还可以运行的线程数量。
acquire()递减计数器，release()则是增加计数器。
>>> sem = Semaphore(2) >>> >>> def test(): ... with sem: ... for i in range(5): ... print currentThread().name,i ... sleep(0.1) ... >>> >>> for i in range(3): ... Thread(target = test).start() ... Thread-5 0//线程5和6同时执行，获取计数器，使其减为0，故使得线程7被阻塞 Thread-6 0 >>> Thread-5 1 Thread-6 1 Thread-5 2 Thread-6 2 Thread-5 3 Thread-6 3 Thread-5 4 Thread-6 4//线程5和线程6执行完成后，释放信号量，线程7开始执行 Thread-7 0 Thread-7 1 Thread-7 2 Thread-7 3 Thread-7 4
线程5和6同时执行，获取计数器，使其减为0，故使得线程7被阻塞,故前面输出只有线程5和线程6。
在线程5和线程6执行完成后，释放信号量，线程7开始执行。
Timer
用一个独立线程在n秒后执行某个函数。如定时器尚未执行，可用cancel()取消，定时器仅执行一次。
>>> import datetime >>> from threading import * >>> >>> def test(): ... print datetime.datetime.now() ... >>> Timer(2,test).start() >>> 2013-10-29 21:28:07.990131
mark：import datetime和from datetime import *
Local
TLS(thread-lock storage)为线程提供独立的存储空间。
>>> from threading import * >>> >>> from time import sleep >>> >>> data = local() >>> >>> def test(fn,x): ... data.x = x ... ... for i in range(5): ... data.x = fn(data.x) ... print currentThread().name,data.x ... sleep(0.1) ... ... >>> >>> t1 = (lambda x:x+1,0) >>> t2 = (lambda x:x+'a','a') >>> >>> for d in (t1,t2): ... Thread(target = test,args = d).start() ... Thread-1 1 Thread-2 aa >>> Thread-1 2 Thread-2 aaa Thread-1 3 Thread-2 aaaa Thread-1 4 Thread-2 aaaaa Thread-1 5 Thread-2 aaaaaa