Python 之 threading

创建多线程常用的三种方法：

• 创建Thread的实例，传给它一个函数
• 创建Thread的实例，传给它一个可调用的类实例（不推荐）
• 派生Thread的子类，并创建子类的实例（推荐）

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

 #!/usr/bin/env python
 # coding:utf-8

 import threading
 from time import ctime, sleep

 loops = [4, 2]

 def loop(n, sec):
     print 'start loop', n, ' at: ', ctime()
     sleep(sec)
     print 'loop', n, ' 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 to finish
         threads[i].join()

     print 'all DONE at: ', ctime()

 if __name__ == '__main__':
     main()

执行结果：

liuqian@ubuntu:~$ python test_threading1.py
starting at:  Wed Jul 20 13:20:06 2016
start loop 0  at:  Wed Jul 20 13:20:06 2016
start loop 1  at:  Wed Jul 20 13:20:06 2016
loop 1  done at:  Wed Jul 20 13:20:08 2016
loop 0  done at:  Wed Jul 20 13:20:10 2016
all DONE at:  Wed Jul 20 13:20:10 2016

【说明】

join([timeout])方法将等待线程结束，或者在提供了超时时间的情况下达到超时时间。对于join()方法而言，其实它根本不需要调用。一旦线程启动，它就会一直执行，直到给定的函数完成后退出。如果主线程还有其他事情要去做，而不是等待这些线程完成（例如其他处理或者等待新的客户端请求），就可以不调用join()。join()只在你需要等待线程完成的时候才是有用的。

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

 #!/usr/bin/env python
 # coding:utf-8

 import threading
 from time import ctime, sleep

 loops = [4,2]

 class ThreadFunc(object):

     def __init__(self, func, args, name=''):
         self.name = name
         self.func = func
         self.args = args

     def __call__(self):
         self.func(*self.args)

 def loop(n, sec):
     print 'start loop', n, ' at: ', ctime()
     sleep(sec)
     print 'loop', n, ' 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__))
         threads.append(t)

     for i in nloops:    # start threads
         threads[i].start()

     for i in nloops:    # wait for all threads to finish
         threads[i].join()

     print 'all DONE at: ', ctime()

 if __name__ == '__main__':
     main()

输出与第一个案例一样。

【说明】当创建新线程时，Thread类的代码将调用ThreadFunc对象，此时会调用__cal__()这个特殊方法。

派生Thread的子类，并创建子类的实例（推荐）

 #!/usr/bin/env python
 # coding:utf-8

 import threading
 from time import ctime, sleep

 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.func(*self.args)

 def loop(n, sec):
     print 'start loop', n, ' at: ', ctime()
     sleep(sec)
     print 'loop', n, ' 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:    # start threads
         threads[i].start()

     for i in nloops:    # wait for all threads to finish
         threads[i].join()

     print 'all DONE at: ', ctime()

 if __name__ == '__main__':
     main()