详解Python中的多线程编程

一、简介

       多线程编程技术可以实现代码并行性，优化处理能力，同时功能的更小划分可以使代码的可重用性更好。Python中threading和Queue模块可以用来实现多线程编程。
二、详解
1、线程和进程
       进程（有时被称为重量级进程）是程序的一次执行。每个进程都有自己的地址空间、内存、数据栈以及其它记录其运行轨迹的辅助数据。操作系统管理在其上运行的所有进程，并为这些进程公平地分配时间。进程也可以通过fork和spawn操作来完成其它的任务，不过各个进程有自己的内存空间、数据栈等，所以只能使用进程间通讯（IPC），而不能直接共享信息。
       线程（有时被称为轻量级进程）跟进程有些相似，不同的是所有的线程运行在同一个进程中，共享相同的运行环境。它们可以想像成是在主进程或“主线程”中并行运行的“迷你进程”。线程有开始、顺序执行和结束三部分，它有一个自己的指令指针，记录自己运行到什么地方。线程的运行可能被抢占(中断)或暂时的被挂起(也叫睡眠)让其它的线程运行，这叫做让步。一个进程中的各个线程之间共享同一片数据空间，所以线程之间可以比进程之间更方便地共享数据以及相互通讯。线程一般都是并发执行的，正是由于这种并行和数据共享的机制使得多个任务的合作变为可能。实际上，在单CPU的系统中，真正的并发是不可能的，每个线程会被安排成每次只运行一小会，然后就把CPU让出来，让其它的线程去运行。在进程的整个运行过程中，每个线程都只做自己的事，在需要的时候跟其它的线程共享运行的结果。多个线程共同访问同一片数据不是完全没有危险的，由于数据访问的顺序不一样，有可能导致数据结果的不一致的问题，这叫做竞态条件。而大多数线程库都带有一系列的同步原语，来控制线程的执行和数据的访问。
2、使用线程
（1）全局解释器锁(GIL)
       Python代码的执行由Python虚拟机(也叫解释器主循环)来控制。Python在设计之初就考虑到要在主循环中，同时只有一个线程在执行。虽然 Python 解释器中可以“运行”多个线程，但在任意时刻只有一个线程在解释器中运行。
       对Python虚拟机的访问由全局解释器锁(GIL)来控制，正是这个锁能保证同一时刻只有一个线程在运行。在多线程环境中，Python 虚拟机按以下方式执行：a、设置 GIL；b、切换到一个线程去运行；c、运行指定数量的字节码指令或者线程主动让出控制(可以调用 time.sleep(0))；d、把线程设置为睡眠状态；e、解锁 GIL；d、再次重复以上所有步骤。
        在调用外部代码(如 C/C++扩展函数)的时候，GIL将会被锁定，直到这个函数结束为止(由于在这期间没有Python的字节码被运行，所以不会做线程切换)编写扩展的程序员可以主动解锁GIL。
（2）退出线程
       当一个线程结束计算，它就退出了。线程可以调用thread.exit()之类的退出函数，也可以使用Python退出进程的标准方法，如sys.exit()或抛出一个SystemExit异常等。不过，不可以直接“杀掉”("kill")一个线程。
        不建议使用thread模块，很明显的一个原因是，当主线程退出的时候，所有其它线程没有被清除就退出了。另一个模块threading就能确保所有“重要的”子线程都退出后，进程才会结束。
（3）Python的线程模块
       Python提供了几个用于多线程编程的模块，包括thread、threading和Queue等。thread和threading模块允许程序员创建和管理线程。thread模块提供了基本的线程和锁的支持，threading提供了更高级别、功能更强的线程管理的功能。Queue模块允许用户创建一个可以用于多个线程之间共享数据的队列数据结构。
       避免使用thread模块，因为更高级别的threading模块更为先进，对线程的支持更为完善，而且使用thread模块里的属性有可能会与threading出现冲突；其次低级别的thread模块的同步原语很少(实际上只有一个)，而threading模块则有很多；再者，thread模块中当主线程结束时，所有的线程都会被强制结束掉，没有警告也不会有正常的清除工作，至少threading模块能确保重要的子线程退出后进程才退出。
3、thread模块
       thread模块除了产生线程外，thread模块也提供了基本的同步数据结构锁对象（lock object也叫原语锁、简单锁、互斥锁、互斥量、二值信号量）。同步原语与线程的管理是密不可分的。
        常用的线程函数以及LockType类型的锁对象的方法：

  #!/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() 

  #!/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 threads...' 
    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() 

  #!/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:      # start threads 
      threads[i].start() 
   
    for i in nloops:      # wait for all 
      threads[i].join()    # threads to finish 
   
    print '---all DONE at:', ctime() 
   
  if __name__ == '__main__': 
    main() 

  #!/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:  # create all threads 
      t = threading.Thread(target=ThreadFunc(loop, (i, loops[i]), loop.__name__)) 
      threads.append(t) 
   
    for i in nloops:  # start all threads 
      threads[i].start() 
   
    for i in nloops:  # wait for completion 
      threads[i].join() 
   
    print 'all DONE at:', ctime() 
   
  if __name__ == '__main__': 
    main() 

  #!/usr/bin/env python 
   
  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 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() 
   
  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() 

  #!/usr/bin/env python 
   
  from random import randint 
  from time import 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()