18.1没有线程支持
#!/usr/bin/env python
# -*- coding:utf-8 -*-
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 'staring at:', ctime()
loop0()
loop1()
print 'all DONE at:', ctime() if __name__ == '__main__':
main()
18.2thread线程支持
#!/usr/bin/env python
# -*- 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():
print 'starting at:', ctime()
thread.start_new_thread(loop0, ())
# 函数start_new_thread()产生一个新线程来运行函数loop0() thread.start_new_thread(loop1, ())
# 同上，两个线程同同时运行 sleep(6) # 主线程睡眠等待；如果主线程（此程序本身）没有停下来，就会直接运行下一条语句，不会等待两个线程运行完毕
print 'all DONE at: ', ctime() if __name__ == '__main__':
main()
18.3 使用线程和锁
#!/usr/bin/env python
# -*- coding:utf-8 -*- import thread
from time import sleep, ctime loops = [4, 2]
# 1储存每个循环的睡眠时间
# 2间接说明了循环的个数 def loop(nloop, nsec, lock):
"""记录循环的号码和睡眠时间，并添加锁"""
print 'start loop', nloop, 'at:', ctime()
sleep(nsec)
print 'loop', nloop, 'done at:', ctime()
lock.release() # 当sleep()时间结束，释放锁用以通知主线程，此子线程已结束 def main():
"""包含三个循环：创建锁；创建线程并分配锁；线程结束并解锁"""
print 'Starting at:', ctime()
locks = []
nloops = range(len(loops)) # 利用列表元素个数说明循环次数 for i in nloops:
lock = thread.allocate_lock() # 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()
18.4使用threaging 模块
#!usr/bin/env python
# -*- coding:utf-8 -*- """创建一个Thread（threading模块中的类）的实例，传给它一个函数""" import threading
from time import sleep, ctime loops = [4, 2]
# 1储存每个循环的睡眠时间
# 2间接说明了循环的个数 def loop(nloop, nsec):
"""1记录循环的号码 2记录睡眠时间"""
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]))
# 1实例化Thread类对象，将函数（target）和参数（args）传入，得到返回的Thread实例：线程对象t。
# 2实例化（调用）Thread类时，不会像thread.star_new_thread那样，线程立即开始，这样可以更好的同步。
threads.append(t) # 创建对象列表 for i in nloops:
threads[i].start() # 开始线程的执行 for i in nloops:
threads[i].join()
# 1调用join()方法后，主线程会等到线程结束才执行下条语句，相比使用等待锁释放的无线循环（自旋锁）更为清楚。
# 2若主线程除了等待线程结束外，还有其他事情要做（如处理或等待其他的客户请求），就不用调用join()。主线程
# 依然会等待线程执行完毕。 print 'all DONE at:', ctime() if __name__ == '__main__':
main()
18.5使用threading模块
#!/usr/bin/env python
# -*- coding:utf-8 -*- """创建一个Thread实例，传给它一个可调用的类对象""" import threading
from time import sleep, ctime loops = [4, 2]
# 1储存每个列表的循环时间
# 2间接说明循环的个数 class ThreadFunc(object):
"""
想让这个类在调用函数方面尽量地通用，并不局限与loop()函数。
这个类保存了函数本身，函数的参数，以及函数名字的字符串。
构造函数__init__()中做了这些值的赋值操作。
""" def __init__(self, func, args, name=''):
super(ThreadFunc, self).__init__()
self.name = name
self.func = func
self.args = args def __call__(self): # 用来执行类中的函数
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__))
# 1.实例化Thread对象时，同时也会实例化ThreadFunction对象，即实例化了两个对象
# 2.由于已经有了要用的参数，就不用额外添加参数到Thread()的构造器中
# 3.这里时传送类对象，而18.4中传送的是函数 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()