threading 模块对象

threading 的 Thread 类是最主要的运行对象。

Thread 对象的函数

使用 Thread 类，我们介绍三种方法来创建线程。

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

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

●        从 Thread 派生出一个子类，创建一个这个子类的实例

下面看第一种， 创建一个 Thread 的实例，传给它一个函数

我们将初始化一个 Thread 对象，把函数（及其参数）传进去。这种方式实例化一个 Thread 与调用 thread.start_new_thread() 之间的最大区别就是，新线程不会立即开始。当你创建线程对象又不想立即开始执行的时候，这是很有用的。

#coding: utf-8
import threading
from time import sleep, ctime

loops = [4,2]

def  loop(nloop, nsec):
	print 'loop', nloop, 'start at:', ctime()
	print 'loop %d 挂起%d秒' % (nloop, nsec)
	sleep(nsec)
	print 'loop', nloop, 'done at:', ctime()

def main():
	print 'main thread start!'
	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:
		threads[i].start()

	for i in nloops:
		threads[i].join()  #等待线程结束

	print 'all done at:', ctime()

if __name__ == '__main__':
	main()

运行结果：

这种方式就省了管理一堆锁的功夫了，只要对每个线程调用 join() 函数，就会等到线程结束。

另外，如果你的主线程除了等线程结束外，还有其它的事情要做（如处理或等待其它的客户请求），那就不用调用 join() 。一旦线程启动后，就会一直运行，直到线程的函数结束，退出为止。所以只有在你要等待线程结束的时候才要调用 join() 。

第二种方式 ，创建一个 Thread 的实例，传给它一个可调用的类对象

这种方式就是在第一种方式的情况下，将函数封装进类对象里面，由类对象提供功能函数。在创建 Thread 对象时会实例化这个类对象。

#coding: utf-8
import threading
from time import sleep, ctime

loops = [4,2]

class Func(object):
	def __init__(self, func, args, name=""):
		self.name = name
		self.func = func
		self.args =args

	def __call__(self):
		self.res = self.func(*self.args)
		
def  loop(nloop, nsec):
	print 'loop', nloop, 'start at:', ctime()
	print 'loop %d 挂起%d秒' % (nloop, nsec)
	sleep(nsec)
	print 'loop', nloop, 'done at:', ctime()

def main():
	print 'main thread start!'
	threads = []  #线程列表
	nloops = range(len(loops))

	for i in nloops:
		t = threading.Thread(target=Func(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()

创建新线程的时候， Thread 对象会调用我们的 Func 对象，这时会用到一个特殊函数__call__() 。 这是 python 的一个特性，只要定义类型的时候，实现 __call__ 函数，这个类型就成为可调用的。 比如实现了 __call__ 函数的 Func 对象实例 instance ，形如 iinstance(arg1,arg2,...) 实际上调用的就是 instance.__call__(arg1,arg2,...)

第三种方式， 从 Thread 派生出一个子类，创建这个子类的实例

#coding: utf-8
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 run(self):
		self.res = self.func(*self.args)
		
def  loop(nloop, nsec):
	print 'loop', nloop, 'start at:', ctime()
	print 'loop %d 挂起%d秒' % (nloop, nsec)
	sleep(nsec)
	print 'loop', nloop, 'done at:', ctime()

def main():
	print 'main thread start!'
	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()

这种方式使创建线程对象的代码更简洁。