1、Python 多线程学习一、Python 中的线程使用：Python 中使用线程有两种方式：函数或者用类来包装线程对象。1、 函数式：调用 thread 模块中的 start_new_thread()函数来产生新线程。如下例：view plaincopy to clipboardprint? import time import thread def timer(no, interval): cnt = 0 while cnt= 5: print Thread %s released! num=%s%(name,str(num) mylock.release() thread.exit_thr
2、ead() num+=1 print Thread %s released! num=%s%(name,str(num) mylock.release() #Release the lock. def test(): thread.start_new_thread(add_num, (A,) thread.start_new_thread(add_num, (B,) if _name_= _main_: test() Python 在 thread 的基础上还提供了一个高级的线程控制库，就是之前提到过的threading。Python 的 threading module 是在建立在 thre
3、ad module 基础之上的一个 module，在threading module 中，暴露了许多 thread module 中的属性。在 thread module 中，python 提供了用户级的线程同步工具“Lock ”对象。而在 threading module 中， python 又提供了 Lock 对象的变种: RLock 对象。 RLock 对象内部维护着一个 Lock 对象，它是一种可重入的对象。对于 Lock 对象而言，如果一个线程连续两次进行 acquire 操作，那么由于第一次 acquire 之后没有 release，第二次 acquire将挂起线程。这会导致 Lo
4、ck 对象永远不会 release，使得线程死锁。RLock 对象允许一个线程多次对其进行 acquire 操作，因为在其内部通过一个 counter 变量维护着线程 acquire 的次数。而且每一次的acquire 操作必须有一个 release 操作与之对应，在所有的 release 操作完成之后，别的线程才能申请该 RLock 对象。下面来看看如何使用 threading 的 RLock 对象实现同步。view plaincopy to clipboardprint? import threading mylock = threading.RLock() num=0 class myT
5、hread(threading.Thread): def _init_(self, name): threading.Thread._init_(self) self.t_name = name def run(self): global num while True: mylock.acquire() print nThread(%s) locked, Number: %d%(self.t_name, num) if num=4: mylock.release() print nThread(%s) released, Number: %d%(self.t_name, num) break
6、num+=1 print nThread(%s) released, Number: %d%(self.t_name, num) mylock.release() def test(): thread1 = myThread(A) thread2 = myThread(B) thread1.start() thread2.start() if _name_= _main_: test() 我们把修改共享数据的代码成为“临界区” 。必须将所有“临界区”都封闭在同一个锁对象的acquire 和 release 之间。2、 条件同步锁只能提供最基本的同步。假如只在发生某些事件时才访问一个“临界区”
7、，这时需要使用条件变量 Condition。Condition 对象是对 Lock 对象的包装，在创建 Condition 对象时，其构造函数需要一个 Lock 对象作为参数，如果没有这个 Lock 对象参数，Condition 将在内部自行创建一个 Rlock 对象。在Condition 对象上，当然也可以调用 acquire 和 release 操作，因为内部的 Lock 对象本身就支持这些操作。但是 Condition 的价值在于其提供的 wait 和 notify 的语义。条件变量是如何工作的呢？首先一个线程成功获得一个条件变量后，调用此条件变量的 wait()方法会导致这个线程释放这
8、个锁，并进入“blocked”状态，直到另一个线程调用同一个条件变量的notify()方法来唤醒那个进入 “blocked”状态的线程。如果调用这个条件变量的 notifyAll()方法的话就会唤醒所有的在等待的线程。如果程序或者线程永远处于“blocked”状态的话，就会发生死锁。所以如果使用了锁、条件变量等同步机制的话，一定要注意仔细检查，防止死锁情况的发生。对于可能产生异常的临界区要使用异常处理机制中的 finally 子句来保证释放锁。等待一个条件变量的线程必须用 notify()方法显式的唤醒，否则就永远沉默。保证每一个 wait()方法调用都有一个相对应的 notify()调用，当
9、然也可以调用 notifyAll()方法以防万一。生产者与消费者问题是典型的同步问题。这里简单介绍两种不同的实现方法。1， 条件变量view plaincopy to clipboardprint? import threading import time class Producer(threading.Thread): def _init_(self, t_name): threading.Thread._init_(self, name=t_name) def run(self): global x con.acquire() if x 0: con.wait() else: for i
10、 in range(5): x=x+1 print “producing.“ + str(x) con.notify() print x con.release() class Consumer(threading.Thread): def _init_(self, t_name): threading.Thread._init_(self, name=t_name) def run(self): global x con.acquire() if x = 0: print consumer wait1 con.wait() else: for i in range(5): x=x-1 pri
11、nt “consuming.“ + str(x) con.notify() print x con.release() con = threading.Condition() x=0 print start consumer c=Consumer(consumer) print start producer p=Producer(producer) p.start() c.start() p.join() c.join() print x 上面的例子中，在初始状态下，Consumer 处于 wait 状态，Producer 连续生产（对 x 执行增1操作）5次后，notify 正在等待的 Co
12、nsumer。Consumer 被唤醒开始消费（对 x 执行减1操作） 2， 同步队列Python 中的 Queue 对象也提供了对线程同步的支持。使用 Queue 对象可以实现多个生产者和多个消费者形成的 FIFO 的队列。生产者将数据依次存入队列，消费者依次从队列中取出数据。view plaincopy to clipboardprint? # producer_consumer_queue from Queue import Queue import random import threading import time #Producer thread class Producer(t
13、hreading.Thread): def _init_(self, t_name, queue): threading.Thread._init_(self, name=t_name) self.data=queue def run(self): for i in range(5): print “%s: %s is producing %d to the queue!n“ %(time.ctime(), self.getName(), i) self.data.put(i) time.sleep(random.randrange(10)/5) print “%s: %s finished!
14、“ %(time.ctime(), self.getName() #Consumer thread class Consumer(threading.Thread): def _init_(self, t_name, queue): threading.Thread._init_(self, name=t_name) self.data=queue def run(self): for i in range(5): val = self.data.get() print “%s: %s is consuming. %d in the queue is consumed!n“ %(time.ct
15、ime(), self.getName(), val) time.sleep(random.randrange(10) print “%s: %s finished!“ %(time.ctime(), self.getName() #Main thread def main(): queue = Queue() producer = Producer(Pro., queue) consumer = Consumer(Con., queue) producer.start() consumer.start() producer.join() consumer.join() print All t
16、hreads terminate! if _name_ = _main_: main() 在上面的例子中，Producer 在随机的时间内生产一个“产品” ，放入队列中。Consumer 发现队列中有了“产品” ，就去消费它。本例中，由于 Producer 生产的速度快于 Consumer 消费的速度，所以往往 Producer 生产好几个“产品 ”后，Consumer 才消费一个产品。Queue 模块实现了一个支持多 producer 和多 consumer 的 FIFO 队列。当共享信息需要安全的在多线程之间交换时，Queue 非常有用。Queue 的默认长度是无限的，但是可以设置其构造函
17、数的maxsize 参数来设定其长度。Queue 的 put 方法在队尾插入，该方法的原型是：put( item, block, timeout)如果可选参数 block 为 true 并且 timeout 为 None（缺省值） ，线程被 block，直到队列空出一个数据单元。如果 timeout 大于0，在 timeout 的时间内，仍然没有可用的数据单元，Full exception 被抛出。反之，如果 block 参数为 false（忽略 timeout 参数） ，item 被立即加入到空闲数据单元中，如果没有空闲数据单元，Full exception 被抛出。Queue 的 get 方法是从队首取数据，其参数和 put 方法一样。如果 block 参数为 true 且 timeout为 None（缺省值） ，线程被 block，直到队列中有数据。如果 timeout 大于0，在 timeout 时间内，仍然没有可取数据，Empty exception 被抛出。反之，如果 block 参数为 false（忽略 timeout 参数） ，队列中的数据被立即取出。如果此时没有可取数据，Empty exception 也会被抛出。
