Python多线程学习

基础不必多讲，还是直接进入python。

    Python代码代码的执行由python虚拟机（也叫解释器主循环）来控制。Python在设计之初就考虑到要在主循环中，同时只有一个线程在执行，就像单CPU的系统中运行多个进程那样，内存中可以存放多个程序，但任意时候，只有一个程序在CPU中运行。同样，虽然python解释器可以“运行”多个线程，但在任意时刻，只有一个线程在解释器中运行。

    对python虚拟机的访问由全局解释器锁（GIL）来控制，这个GIL能保证同一时刻只有一个线程在运行。在多线程环境中，python虚拟机按以下方式执行：

   1 设置GIL
   2 切换到一个线程去运行
   3 运行：（a.指定数量的字节码指令，或者b.线程主动让出控制（可以调用time.sleep()））
   4 把线程设置为睡眠状态
   5 解锁GIL
   6 重复以上所有步骤

   那么为什么要提出多线程呢？我们首先看一个单线程的例子。

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()

运行结果：
>>>
starting at: Mon Aug 31 10:27:23 2009
start loop 0 at: Mon Aug 31 10:27:23 2009
loop 0 done at: Mon Aug 31 10:27:27 2009
start loop 1 at: Mon Aug 31 10:27:27 2009
loop 1 done at: Mon Aug 31 10:27:29 2009
all DONE at: Mon Aug 31 10:27:29 2009
>>>

     可以看到单线程中的两个循环， 只有一个循环结束后另一个才开始。  总共用了6秒多的时间。假设两个loop中执行的不是sleep，而是一个别的运算的话，如果我们能让这些运算并行执行的话，是不是可以减少总的运行时间呢，这就是我们提出多线程的前提。


Python中的多线程模块：thread，threading，Queue。

1  thread 

     这个模块一般不建议使用。下面我们直接把以上的例子改一下，演示一下。

from time import sleep,ctime
import thread

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()
  
运行结果：
>>>
starting at: Mon Aug 31 11:04:39 2009
start loop 0 at: Mon Aug 31 11:04:39 2009
start loop 1 at: Mon Aug 31 11:04:39 2009
loop 1 done at: Mon Aug 31 11:04:41 2009
loop 0 done at: Mon Aug 31 11:04:43 2009
all DONE at: Mon Aug 31 11:04:45 2009
>>>
可以看到实际是运行了4秒两个loop就完成了。效率确实提高了。


2 threading模块

   首先看一下threading模块中的对象：
   Thread    ：表示一个线程的执行的对象
   Lock     ：锁原语对象
   RLock    ：可重入锁对象。使单线程可以再次获得已经获得的锁
   Condition  ：条件变量对象能让一个线程停下来，等待其他线程满足了某个“条件”，如状态的改变或值的改变
   Event     ：通用的条件变量。多个线程可以等待某个事件发生，在事件发生后，所有的线程都被激活
   Semaphore  ：为等待锁的线程提供一个类似“等候室”的结构
   BoundedSemaphore  ：与semaphore类似，只是它不允许超过初始值
   Timer       ：  与Thread类似，只是，它要等待一段时间后才开始运行


其中Thread类是你主要的运行对象，它有很多函数，用它你可以用多种方法来创建线程，常用的为以下三种。
     (1)创建一个Thread的实例，传给它一个函数
     (2)创建一个Thread实例，传给它一个可调用的类对象
     (3)从Thread派生出一个子类，创建一个这个子类的实例

Thread类的函数有：

       getName(self)  返回线程的名字
     |
     |  isAlive(self)  布尔标志，表示这个线程是否还在运行中
     |
     |  isDaemon(self)  返回线程的daemon标志
     |
     |  join(self, timeout=None) 程序挂起，直到线程结束，如果给出timeout，则最多阻塞timeout秒
     |
     |  run(self)  定义线程的功能函数
     |
     |  setDaemon(self, daemonic)  把线程的daemon标志设为daemonic
     |
     |  setName(self, name)  设置线程的名字
     |
     |  start(self)   开始线程执行


下面看一个例子：

（方法一：创建Thread实例，传递一个函数给它）
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()

    可以看到第一个for循环，我们创建了两个线程，这里用到的是给Thread类传递了函数，把两个线程保存到threads列表中，第二个for循环是让两个线程开始执行。然后再让每个线程分别调用join函数，使程序挂起，直至两个线程结束。

另外的例子：

（方法二：创建一个实例，传递一个可调用的类的对象）

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):
              self.res=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()


最后的方法：

（方法三：创建一个这个子类的实例）
import threading
from time import sleep,ctime

loops=(4,2)

class MyThread(threading.Thread):
       def __init__(self,func,args,name=''):
              threading.Thread.__init__(self)
              self.name=name
              self.func=func
              self.args=args
       def run(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=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单独编成一个脚本模块，然后我们可以在别的程序里导入这个模块直接使用。

#####################

一、Python中的线程使用：

    Python中使用线程有两种方式：函数或者用类来包装线程对象。

1、  函数式：

调用thread模块中的start_new_thread()函数来产生新线程。如下例：

view plaincopy to clipboardprint?

1. import time  
2. import thread  
3. def timer(no, interval):  
4.     cnt = 0  
5.     while cnt<10:  
6.         print 'Thread:(%d) Time:%s\n'%(no, time.ctime())  
7.         time.sleep(interval)  
8.         cnt+=1  
9.     thread.exit_thread()  
10.      
11.    
12. def test(): #Use thread.start_new_thread() to create 2 new threads  
13.     thread.start_new_thread(timer, (1,1))  
14.     thread.start_new_thread(timer, (2,2))  
15.    
16. if __name__=='__main__':  
17.     test()  

    上面的例子定义了一个线程函数timer,它打印出10条时间记录后退出，每次打印的间隔由interval参数决定。thread.start_new_thread(function, args[, kwargs])的第一个参数是线程函数（本例中的timer方法），第二个参数是传递给线程函数的参数，它必须是tuple类型，kwargs是可选参数。

    线程的结束可以等待线程自然结束，也可以在线程函数中调用thread.exit()或thread.exit_thread()方法。

2、  创建threading.Thread的子类来包装一个线程对象

如下例：

1. import threading  
2. import time  
3. class timer(threading.Thread): #The timer class is derived from the class threading.Thread  
4.     def __init__(self, num, interval):  
5.         threading.Thread.__init__(self)  
6.         self.thread_num = num  s
7.         self.interval = interval  
8.         self.thread_stop = False  
9.    
10.     def run(self): #Overwrite run() method, put what you want the thread do here  
11.         while not self.thread_stop:  
12.             print 'Thread Object(%d), Time:%s\n' %(self.thread_num, time.ctime())  
13.             time.sleep(self.interval)  
14.     def stop(self):  
15.         self.thread_stop = True  
16.          
17.    
18. def test():  
19.     thread1 = timer(1, 1)  
20.     thread2 = timer(2, 2)  
21.     thread1.start()  
22.     thread2.start()  
23.     time.sleep(10)  
24.     thread1.stop()  
25.     thread2.stop()  
26.     return  
27.    
28. if __name__ == '__main__':  
29.     test()  

    就我个人而言，比较喜欢第二种方式，即创建自己的线程类，必要时重写threading.Thread类的方法，线程的控制可以由自己定制。

threading.Thread类的使用：

     1，在自己的线程类的__init__里调用threading.Thread.__init__(self, name = threadname)  , Threadname为线程的名字

     2， run()，通常需要重写，编写代码实现做需要的功能。

     3，getName()，获得线程对象名称

     4，setName()，设置线程对象名称

     5，start()，启动线程

     6，jion([timeout])，等待另一线程结束后再运行。

     7，setDaemon(bool)，设置子线程是否随主线程一起结束，必须在start()之前调用。默认为False。

     8，isDaemon()，判断线程是否随主线程一起结束。

     9，isAlive()，检查线程是否在运行中。

    此外threading模块本身也提供了很多方法和其他的类，可以帮助我们更好的使用和管理线程。可以参看http://www.python.org/doc/2.5.2/lib/module-threading.html。

   假设两个线程对象t1和t2都要对num=0进行增1运算，t1和t2都各对num修改10次，num的最终的结果应该为20。但是由于是多线程访问，有可能出现下面情况：在num=0时，t1取得num=0。系统此时把t1调度为”sleeping”状态，把t2转换为”running”状态，t2页获得num=0。然后t2对得到的值进行加1并赋给num，使得num=1。然后系统又把t2调度为”sleeping”，把t1转为”running”。线程t1又把它之前得到的0加1后赋值给num。这样，明明t1和t2都完成了1次加1工作，但结果仍然是num=1。

    上面的case描述了多线程情况下最常见的问题之一：数据共享。当多个线程都要去修改某一个共享数据的时候，我们需要对数据访问进行同步。

1、  简单的同步

   最简单的同步机制就是“锁”。锁对象由threading.RLock类创建。线程可以使用锁的acquire()方法获得锁，这样锁就进入“locked”状态。每次只有一个线程可以获得锁。如果当另一个线程试图获得这个锁的时候，就会被系统变为“blocked”状态，直到那个拥有锁的线程调用锁的release()方法来释放锁，这样锁就会进入“unlocked”状态。“blocked”状态的线程就会收到一个通知，并有权利获得锁。如果多个线程处于“blocked”状态，所有线程都会先解除“blocked”状态，然后系统选择一个线程来获得锁，其他的线程继续沉默（“blocked”）。

     Python中的thread模块和Lock对象是Python提供的低级线程控制工具，使用起来非常简单。如下例所示：

1. import thread  
2. import time  
3. mylock = thread.allocate_lock()  #Allocate a lock  
4. num=0  #Shared resource  
5.   
6. def add_num(name):  
7.     global num  
8.     while True:  
9.         mylock.acquire() #Get the lock   
10.         # Do something to the shared resource  
11.         print 'Thread %s locked! num=%s'%(name,str(num))  
12.         if num >= 5:  
13.             print 'Thread %s released! num=%s'%(name,str(num))  
14.             mylock.release()  
15.             thread.exit_thread()  
16.         num+=1  
17.         print 'Thread %s released! num=%s'%(name,str(num))  
18.         mylock.release()  #Release the lock.  
19.   
20. def test():  
21.     thread.start_new_thread(add_num, ('A',))  
22.     thread.start_new_thread(add_num, ('B',))  
23.   
24. if __name__== '__main__':  
25.     test()  

     Python 在thread的基础上还提供了一个高级的线程控制库，就是之前提到过的threading。Python的threading module是在建立在thread module基础之上的一个module，在threading module中，暴露了许多thread module中的属性。在thread module中，python提供了用户级的线程同步工具“Lock”对象。而在threading module中，python又提供了Lock对象的变种: RLock对象。RLock对象内部维护着一个Lock对象，它是一种可重入的对象。

  (1)对于Lock对象而言，如果一个线程连续两次进行acquire操作，那么由于第一次acquire之后没有release，第二次acquire将挂起线程。这会导致Lock对象永远不会release，使得线程死锁。

     (2)RLock对象允许一个线程多次对其进行acquire操作，因为在其内部通过一个counter变量维护着线程acquire的次数。而且每一次的acquire操作必须有一个release操作与之对应，在所有的release操作完成之后，别的线程才能申请该RLock对象。

  下面来看看如何使用threading的RLock对象实现同步。

view plaincopy to clipboardprint?

1. import threading  
2. mylock = threading.RLock()  
3. num=0  
4.    
5. class myThread(threading.Thread):  
6.     def __init__(self, name):  
7.         threading.Thread.__init__(self)  
8.         self.t_name = name  
9.           
10.     def run(self):  
11.         global num  
12.         while True:  
13.             mylock.acquire()  
14.             print '\nThread(%s) locked, Number: %d'%(self.t_name, num)  
15.             if num>=4:  
16.                 mylock.release()  
17.                 print '\nThread(%s) released, Number: %d'%(self.t_name, num)  
18.                 break  
19.             num+=1  
20.             print '\nThread(%s) released, Number: %d'%(self.t_name, num)  
21.             mylock.release()  
22.               
23. def test():  
24.     thread1 = myThread('A')  
25.     thread2 = myThread('B')  
26.     thread1.start()  
27.     thread2.start()  
28.    
29. if __name__== '__main__':  
30.     test()  

 

     我们把修改共享数据的代码成为“临界区”。必须将所有“临界区”都封闭在同一个锁对象的acquire和release之间。

2、  条件同步

  锁只能提供最基本的同步。假如只在发生某些事件时才访问一个“临界区”，这时需要使用条件变量Condition。

     Condition对象是对Lock对象的包装，在创建Condition对象时，其构造函数需要一个Lock对象作为参数，如果没有这个Lock对象参数，Condition将在内部自行创建一个Rlock对象。在Condition对象上，当然也可以调用acquire和release操作，因为内部的Lock对象本身就支持这些操作。但是Condition的价值在于其提供的wait和notify的语义。

  条件变量是如何工作的呢？首先一个线程成功获得一个条件变量后，调用此条件变量的wait()方法会导致这个线程释放这个锁，并进入“blocked”状态，直到另一个线程调用同一个条件变量的notify()方法来唤醒那个进入“blocked”状态的线程。如果调用这个条件变量的notifyAll()方法的话就会唤醒所有的在等待的线程。

  如果程序或者线程永远处于“blocked”状态的话，就会发生死锁。所以如果使用了锁、条件变量等同步机制的话，一定要注意仔细检查，防止死锁情况的发生。对于可能产生异常的临界区要使用异常处理机制中的finally子句来保证释放锁。等待一个条件变量的线程必须用notify()方法显式的唤醒，否则就永远沉默。保证每一个wait()方法调用都有一个相对应的notify()调用，当然也可以调用notifyAll()方法以防万一。

  生产者与消费者问题是典型的同步问题。这里简单介绍两种不同的实现方法。

1，  条件变量

 

view plaincopy to clipboardprint?

1. import threading  
2. import time  
3.   
4. class Producer(threading.Thread): 
5.     def __init__(self, t_name):  
6.         threading.Thread.__init__(self, name=t_name)  
7.       
8.     def run(self): 
9.         global x  
10.         con.acquire()  
11.         if x > 0:  
12.             con.wait()  
13.         else:  
14.             for i in range(5):  
15.                 x=x+1  
16.                 print "producing..." + str(x)  
17.             con.notify()  
18.         print x  
19.         con.release()  
20.    
21. class Consumer(threading.Thread):  
22.     def __init__(self, t_name):  
23.         threading.Thread.__init__(self, name=t_name)  
24.   
25.     def run(self):  
26.         global x  
27.         con.acquire()  
28.         if x == 0:  
29.             print 'consumer wait1'  
30.             con.wait()  
31.         else:  
32.             for i in range(5):  
33.                 x=x-1  
34.                 print "consuming..." + str(x)  
35.             con.notify()  
36.         print x  
37.         con.release()  
38.   
39. con = threading.Condition()  
40. x=0  
41.   
42. print 'start consumer'  
43. c=Consumer('consumer')  
44.   
45. print 'start producer'  
46. p=Producer('producer')  
47.   
48. p.start()  
49. c.start()  
50. p.join()  
51. c.join()  
52. print x  

    上面的例子中，在初始状态下，Consumer处于wait状态，Producer连续生产（对x执行增1操作）5次后，notify正在等待的Consumer。Consumer被唤醒开始消费（对x执行减1操作） 

2，  同步队列

     Python中的Queue对象也提供了对线程同步的支持。使用Queue对象可以实现多个生产者和多个消费者形成的FIFO的队列。

  生产者将数据依次存入队列，消费者依次从队列中取出数据。 

view plaincopy to clipboardprint?

1. # producer_consumer_queue  
2.   
3. from Queue import Queue  
4. import random  
5. import threading  
6. import time 
7.   
8. #Producer thread  
9. class Producer(threading.Thread):  
10.     def __init__(self, t_name, queue):  
11.         threading.Thread.__init__(self, name=t_name)  
12.         self.data=queue  
13.   
14.     def run(self):  
15.         for i in range(5):  
16.             print "%s: %s is producing %d to the queue!\n" %(time.ctime(), self.getName(), i)  
17.             self.data.put(i)  
18.             time.sleep(random.randrange(10)/5)  
19.         print "%s: %s finished!" %(time.ctime(), self.getName())  
20.   
21. #Consumer thread  
22. class Consumer(threading.Thread):  
23.     def __init__(self, t_name, queue):  
24.         threading.Thread.__init__(self, name=t_name)  
25.         self.data=queue  
26.   
27.     def run(self):  
28.         for i in range(5):  
29.             val = self.data.get()  
30.             print "%s: %s is consuming. %d in the queue is consumed!\n" %(time.ctime(), self.getName(), val)  
31.             time.sleep(random.randrange(10))  
32.         print "%s: %s finished!" %(time.ctime(), self.getName())
33.   
34. #Main thread  
35. def main():  
36.     queue = Queue()
37.     producer = Producer('Pro.', queue)  
38.     consumer = Consumer('Con.', queue)  
39.     producer.start()  
40.     consumer.start() 
41.     producer.join()  
42.     consumer.join()  
43.     print 'All threads terminate!'  
44.   
45. if __name__ == '__main__':  
46.     main()  

  在上面的例子中，Producer在随机的时间内生产一个“产品”，放入队列中。Consumer发现队列中有了“产品”，就去消费它。本例中，由于Producer生产的速度快于Consumer消费的速度，所以往往Producer生产好几个“产品”后，Consumer才消费一个产品。

     Queue模块实现了一个支持多producer和多consumer的FIFO队列。当共享信息需要安全的在多线程之间交换时，Queue非常有用。Queue的默认长度是无限的，但是可以设置其构造函数的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也会被抛出。