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

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

 

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

   1 设置GIL

   2 切换到一个线程去运行

   3 运行：（a.指定数量的字节码指令，或者b.线程主动让出控制（可以调用time.sleep()））

   4 把线程设置为睡眠状态

   5 解锁GIL

   6 重复以上所有步骤

 

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

1 from time import sleep,ctime 2   3 def loop0(): 4     print 'start loop 0 at:',ctime() 5     sleep(4) 6     print 'loop 0 done at:',ctime() 7   8 def loop1(): 9     print 'start loop 1 at:',ctime()10     sleep(2)11     print 'loop 1 done at:',ctime()12  13 def main():14     print 'starting at:',ctime()15     loop0()16     loop1()17     print 'all DONE at:',ctime()18  19 if __name__=='__main__':20     main()21  22 运行结果：23 >>>24 starting at: Mon Aug 31 10:27:23 200925 start loop 0 at: Mon Aug 31 10:27:23 200926 loop 0 done at: Mon Aug 31 10:27:27 200927 start loop 1 at: Mon Aug 31 10:27:27 200928 loop 1 done at: Mon Aug 31 10:27:29 200929 all DONE at: Mon Aug 31 10:27:29 200930 >>>

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

 

 

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

 

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

1 from time import sleep,ctime 2 import thread 3   4 def loop0(): 5     print 'start loop 0 at:',ctime() 6     sleep(4) 7     print 'loop 0 done at:',ctime() 8   9 def loop1():10     print 'start loop 1 at:',ctime()11     sleep(2)12     print 'loop 1 done at:',ctime()13  14 def main():15     print 'starting at:',ctime()16     thread.start_new_thread(loop0,())17     thread.start_new_thread(loop1,())18     sleep(6)19     print 'all DONE at:',ctime()20  21 if __name__=='__main__':22     main()23    24 运行结果：25 >>>26 starting at: Mon Aug 31 11:04:39 200927 start loop 0 at: Mon Aug 31 11:04:39 200928 start loop 1 at: Mon Aug 31 11:04:39 200929 loop 1 done at: Mon Aug 31 11:04:41 200930 loop 0 done at: Mon Aug 31 11:04:43 200931 all DONE at: Mon Aug 31 11:04:45 200932 >>>

可以看到实际是运行了4秒两个loop就完成了。效率确实提高了。

 

2 threading模块

   首先看一下threading模块中的对象：

   Thread    ：表示一个线程的执行的对象

   Lock     ：锁原语对象

   RLock    ：可重入锁对象。使单线程可以再次获得已经获得的锁

   Condition  ：条件变量对象能让一个线程停下来，等待其他线程满足了某个“条件”，如状态的改变或值的改变

   Event     ：通用的条件变量。多个线程可以等待某个事件发生，在事件发生后，所有的线程都被激活

  Semaphore  ：为等待锁的线程提供一个类似“等候室”的结构

  BoundedSemaphore  ：与semaphore类似，只是它不允许超过初始值

  Timer       ：  与Thread类似，只是，它要等待一段时间后才开始运行

 

 

 其中Thread类是你主要的运行对象，它有很多函数，用它你可以用多种方法来创建线程，常用的为以下三种。

 创建一个Thread的实例，传给它一个函数

 创建一个Thread实例，传给它一个可调用的类对象

 从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实例，传递一个函数给它）

1 import threading 2 from time import sleep,ctime 3   4 loops=[4,2] 5   6 def loop(nloop,nsec): 7        print 'start loop',nloop,'at:',ctime() 8        sleep(nsec) 9        print 'loop',nloop,'done at:',ctime()10 def main():11        print 'starting at:',ctime()12        threads=[]13        nloops=range(len(loops))14        for i in nloops:15               t=threading.Thread(target=loop,args=(i,loops[i]))16               threads.append(t)17        for i in nloops:18               threads[i].start()19        for i in nloops:20               threads[i].join()21              22        print 'all done at:',ctime()23       24 if __name__=='__main__':25        main()

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

 

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

1 import threading 2 from time import sleep,ctime 3   4 loops=[4,2] 5   6 class ThreadFunc(object): 7        def __init__(self,func,args,name=''): 8               self.name=name 9               self.func=func10               self.args=args11        def __call__(self):12               self.res=self.func(*self.args)13 def loop(nloop,nsec):14        print 'start loop',nloop,'at:',ctime()15        sleep(nsec)16        print 'loop',nloop,'done at:',ctime()17 def main():18        print 'starting at:',ctime()19        threads=[]20        nloops=range(len(loops))21        for i in nloops:22               t=threading.Thread(target=ThreadFunc(loop,(i,loops[i]),loop.__name__))23               threads.append(t)24        for i in nloops:25               threads[i].start()26        for i in nloops:27               threads[i].join()28        print 'all done at:',ctime()29  30 if __name__=='__main__':31        main()

最后的方法：（方法三：创建一个这个子类的实例）

1 import threading 2 from time import sleep,ctime 3   4 loops=(4,2) 5   6 class MyThread(threading.Thread): 7        def __init__(self,func,args,name=''): 8               threading.Thread.__init__(self) 9               self.name=name10               self.func=func11               self.args=args12        def run(self):13               apply(self.func,self.args)14 def loop(nloop,nsec):15        print 'start loop',nloop,'at:',ctime()16        sleep(nsec)17        print 'loop',nloop,'done at:',ctime()18       19 def main():20        print 'starting at:',ctime()21        threads=[]22        nloops=range(len(loops))23       24        for i in nloops:25               t=MyThread(loop,(i,loops[i]),loop.__name__)26               threads.append(t)27        for i in nloops:28               threads[i].start()29       30        for i in nloops:31               threads[i].join()32              33        print 'all done at:',ctime()34 if __name__=='__main__':35        main()36

另外我们可以把MyThread单独编成一个脚本模块，然后我们可以在别的程序里导入这个模块直接使用。