参考：http://blog.csdn.net/eastmount/article/details/50155353
代码语言：javascript复制# 1、没有线程的例子
# 使用time.sleep()函数来演示线程的工作，这个例子主要为后面线程做对比。
# time.sleep()需要一个浮点型的参数，来指定“睡眠”的时间（单位秒）。这就相当于程序的运行会被挂起指定的时间。
# 代码解释：两个计时器，loop0睡眠4秒，loop1()睡眠2秒，它们是在一个进程或者线程中，顺序地执行loop0()和loop1()，那总运行时间为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()# result：
Starting at: Wed Jul 26 23:10:41 2017
Start loop 0 at: Wed Jul 26 23:10:41 2017 # loop0() sleep(4)
Loop 0 done at: Wed Jul 26 23:10:45 2017
Start loop 1 at: Wed Jul 26 23:10:45 2017 # loop1() sleep(2)
Loop 1 done at: Wed Jul 26 23:10:47 2017
All done at: Wed Jul 26 23:10:47 2017
[Finished in 6.1s]# 2、避免使用thread模块
# Python提供了几个用于多线程编程的模块，包括thread、threading和Queue等。
# (1) thread模块: 允许程序员创建和管理线程，它提供了基本的线程和锁的支持。
# (2) threading模块: 允许程序员创建和管理线程，它提供了更高级别，更强的线程管理的功能。
# (3) Queue模块: 允许用户创建一个可用于多个线程间共享数据的队列数据结构。
# 下面简单分析为什么需要避免使用thread模块？
# (1) 首先更高级别的threading模块更为先进，对线程的支持更为完善，而且使用thread模块里的属性有可能会与threading出现冲突。
# (2) 其次，低级别的thread模块的同步原语很少（实际只有一个），而threading模块则有很多。
# (3) 另一个原因是thread对你的进程什么时候应该结束完全没有控制，当主线程结束时，所有的线程都会被强制结束掉，没有警告也不会有正常的清除工作。而threading模块能确保重要的子线程退出后进程才退出。
# 当然，为了你更好的理解线程，还是会对thread进行讲解。但是我们只建议那些有经验的专家想访问线程的底层结构时，才使用thread模块。而如果可以，你的第一个线程程序应尽可能使用threading等高级别的模块。# 3、Thread模块实现多线程
# -*- coding: utf-8 -*-
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():
try:
print 'Starting at:', ctime()
thread.start_new_thread(loop0, ())
thread.start_new_thread(loop1, ())
sleep(6) #同步：主线程等待子线程结束后，再结束；否则，直接关闭子线程，没有提示
print 'All done at:', ctime()
except Exception,e:
print 'Error:',e
finally:
print 'ENDn'
if __name__ == '__main__':
main()# result：
Starting at: Thu Jul 27 08:54:20 2017
Start loop 0 at: Thu Jul 27 08:54:20 2017
Start loop 1 at: Thu Jul 27 08:54:20 2017
Loop 1 done at: Thu Jul 27 08:54:22 2017
Loop 0 done at: Thu Jul 27 08:54:24 2017
All done at: Thu Jul 27 08:54:26 2017
END# 4、线程加锁方法
# 那么，有什么好的管理线程的方法呢？而不是在主线程里做个额外的延时6秒操作。因为总的运行时间并不比单线程的代码少；
# 而且使用sleep()函数做线程的同步操作是不可靠的；如果循环的执行时间不能事先确定的话，这可能会造成主线程过早或过晚的退出。
# 这就需要引入锁的概念。下面代码执行loop函数，与前面代码的区别是不用为线程什么时候结束再做额外的等待了。
# 使用锁之后，可以在两个线程都退出后，马上退出。
#coding=utf-8
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 at:', ctime()
locks =[]
nloops = range(len(loops)) #以loops数组创建列表并赋值给nloops
for i in nloops:
lock = thread.allocate_lock() #创建锁对象
lock.acquire() #获取锁对象 加锁
locks.append(lock) #追加到locks[]数组中
#执行多线程 (函数名,函数参数)
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 end:', ctime()
if __name__ == '__main__':
main()# result：
starting at: Thu Jul 27 17:05:25 2017
start loop 0 at: Thu Jul 27 17:05:25 2017
start loop 1 at: Thu Jul 27 17:05:25 2017
loop 1 done at: Thu Jul 27 17:05:27 2017
loop 0 done at: Thu Jul 27 17:05:29 2017
all end: Thu Jul 27 17:05:29 2017
[Finished in 4.5s]# 5、创建Thread实例，传给它一个函数
# 这第一个例子使用方法一，把函数及其参数如上面Thread模块的例子一样传进去。
# 主要变化包括：添加了一些Thread对象；在实例化每个Thread对象时，把函数（target）和参数（args）都传进去，得到返回的Thread实例。
# 实例化一个Thread调用Thread()方法与调用thread.start_new_thread()之间的最大区别是：新的线程不会立即开始。
# 在你创建线程对象，但不想马上开始运行线程的时候，这是一个很有用的同步特性。
# threading模块的Thread类有一个join()函数，允许主线程等待线程的结束。
#coding=utf-8
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)) #列表[0,1]
#创建线程
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 end:', ctime()
if __name__ == '__main__':
main()# result
Starting at: Thu Jul 27 20:44:03 2017
Start loop 0 at: Thu Jul 27 20:44:03 2017
Start loop 1 at: Thu Jul 27 20:44:03 2017
Loop 1 done at: Thu Jul 27 20:44:05 2017
Loop 0 done at: Thu Jul 27 20:44:07 2017
All end: Thu Jul 27 20:44:07 2017
[Finished in 4.2s]
# 所有的线程都创建之后，再一起调用start()函数启动线程，而不是创建一个启动一个。
# 而且，不用再管理一堆锁（分配锁、获得锁、释放锁、检查锁的状态等），只要简单地对每个线程调用join()函数就可以了。
# join()会等到线程结束，或者在给了timeout参数的时候，等到超时为止。使用join()比使用一个等待锁释放的无限循环清楚一些（也称“自旋锁”）。
# join()的另一个比较重要的方法是它可以完全不用调用。一旦线程启动后，就会一直运行，直到线程的函数结束，退出为止。
# 果你的主线程除了等线程结束外，还有其他的事情要做（如处理或等待其他的客户请求），那就不用调用join()，只有在你要等待线程结束的时候才要调用join()。# Thread是线程类，有两种使用方法，直接传入要运行的方法或从Thread继承并覆盖run()：
# coding:utf-8
import threading
import time
#方法一：将要执行的方法作为参数传给Thread的构造方法
def action(arg):
time.sleep(1)
print 'the arg is:%sr' %arg
for i in xrange(4):
t =threading.Thread(target=action,args=(i,))
t.start()
print 'main thread end!'
#方法二：从Thread继承，并重写run()
class MyThread(threading.Thread):
def __init__(self,arg):
super(MyThread, self).__init__()#注意：一定要显式的调用父类的初始化函数。
self.arg=arg
def run(self):#定义每个线程要运行的函数
time.sleep(1)
print 'the arg is:%sr' % self.arg
for i in xrange(4):
t =MyThread(i)
t.start()
print 'main thread end!'
