python提供两个模块支持多线程编程：thread和threading。

一、关于python多线程

Python解释器中可以同时运行多个线程，但是再任意时刻只能有一个线程在解释器运行。Python虚拟机的访问是由全局解锁器（GIL）控制的，由GIL保证同时只有一个线程的运行。

执行方式如下：

1.设置GIL

2.切换进一个进程执行

3.执行下面操作中的一个

　　a.运行指定数量的字节码（操作系统中是由时钟控制的）

　　b.线程主动出让控制权

4.把线程设置为睡眠状态，即切换出线程

5.解锁GIL

6.重复以上步骤

注意：1.调用外部代码时（C/C++扩展的内置函数），GIL保持锁定，因为外部代码没有Python字节码.

　　　2.I/O密集型的Python程序要比计算密集型的程序更好的利用多线程。

二、关于thread模块的多线程

示例1，当没用使用多线程时：

from time import sleep, ctime

def loop():
    print('start loop0 at:', ctime())
    sleep(4)
    print('loop 0 done at:', ctime())

def loop1():
    print('start loop1 at:', ctime())
    sleep(2)
    print('loop1 done at:', ctime())

def main():
    print('starting at:', ctime())
    loop()
    loop1()
    print('loop1 done at:', ctime())

if __name__ == '__main__':
    main()

输出结果为：

starting at: Mon Dec 19 22:17:42 2016
start loop0 at: Mon Dec 19 22:17:42 2016
loop 0 done at: Mon Dec 19 22:17:46 2016
start loop1 at: Mon Dec 19 22:17:46 2016
loop1 done at: Mon Dec 19 22:17:48 2016
loop1 done at: Mon Dec 19 22:17:48 2016

从结果可以看出loop0和loop按照顺序执行，耗时一共6s

thread模块的核心函数是：start_new_thread()

用法：_thread.start_new_thread(func, *arg, **kwargs)

示例2，当使用多线程时候：

import _thread
from time import sleep, ctime

def loop0():
    print('start loop0 at:', ctime())
    sleep(4)
    print('loop0 done at:', ctime())

def loop1():
    print('start loop1 at:', ctime())
    sleep(2)
    print('loop1 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 Dec 19 22:27:57 2016
start loop0 at: Mon Dec 19 22:27:57 2016
start loop1 at: Mon Dec 19 22:27:57 2016
loop1 done at: Mon Dec 19 22:27:59 2016
loop0 done at: Mon Dec 19 22:28:01 2016
all done at: Mon Dec 19 22:28:03 2016

从结果可以看出，1.结果不是按照顺序输出的，loop0后结束

　　　　　　　　2.loop0和loop1的运行时间一共是4s，比没有使用多线程快了2s

　　　　　　　　3.sleep(6)是针对主线程的，预计loop0和loop1会在6s前执行完毕。

如果我们把主线程的执行时间设定为3s，那么结果就有意思了

starting at: Mon Dec 19 22:33:01 2016 start loop0 at: Mon Dec 19 22:33:01 2016 start loop1 at: Mon Dec 19 22:33:01 2016 loop1 done at: Mon Dec 19 22:33:03 2016 all done at: Mon Dec 19 22:33:04 2016

从这里也可以看出，对主线程执行sleep()来达到同步的目的不可靠，所以引入锁的概念。

用锁怎么实现多线程呢？对于每一个子线程，我们都给它加锁，在执行结束后再释放锁，这样主线程的工作就是检查没一个子线程的加锁状态，如果都已经释放锁了，那就表示子线程全部执行结束，就可以退出了。

示例3，使用锁的多线程：

#coding: utf-8  
import thread  
from time import sleep, ctime  
  
loops = [4,2]  
  
def  loop(nloop, nsec, lock):  
    print 'loop', nloop, 'start at:', ctime()  
    print 'loop %d 挂起%d秒' % (nloop, nsec)  
    sleep(nsec)  
    print 'loop', nloop, 'done at:', ctime()  
    lock.release()  #释放锁
  
def main():  
    print 'main thread start!'  
    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()  

实际上，我们不建议使用thread模块。首先，更高级别的threading模块更为先进，对线程的支持更为完善，而且使用thread模块里的属性有可能会与threading出现冲突。其次，低级别的thread模块的同步原语只有一个，而threading模块则有很多。

还有一个原因是，使用thread对于你的进程什么时候应该结束完全没有控制，当主线程结束时，所有的线程都会被强制结束掉，没有警告也不会有正常的清除工作。但是threading模块能确保重要的子线程退出后进程才退出。

不过如果想访问线程的底层结构，那就可能要使用thread模块了。

本文参考： https://www.cnblogs.com/fcyworld/p/6200968.html http://blog.csdn.net/whoami021/article/details/21265031