threading模块

#更高级别的threading不仅提供了Thread类，还提供了各种非常好用的同步机制。

#_thread模块不支持守护线程，当主线程退出时，所有子线程无论是否在工作，都会被强制退出。threading模块支持守护线程，守护线程一般时一个等待客户请求的服务器，如果没有客户提出请求，就一直等着。如果设定一个线程为守护线程，就表示这个线程不重要，在进程退出时，不用等待这个线程退出。如果主线程退出时不用等待子线程完成，就要设定这些线程的daemon属性，即在线程Thread.start()开始前，调用setDaemon()函数设定线程的daemon标志（Thread.setDaemon(True)）,表示这个线程“不重要”，如果一定要等待子线程执行完成再退出主线程，就什么都不用做或显式调用Thread.setDaemon(False)以保证daemon标志为False，可以调用Thread.isDaemon()函数判断daemon标志的值。新的子线程会继承父线程的daemon标志，整个Python在所有非守护线程退出后才会结束，即进程中没有非守护线程存在时才会结束。

 

threading的thread类

#Thread有很多_thread模块里没有的函数，Thread对象的函数很丰富。下面创建一个Thread的实例，传给他一个函数。示例如下：

#!/usr/bin/python3
#-*-coding:UTF-8-*-
#threading的thread类

import threading
from time import sleep
from datetime import datetime

loops=[4,2]
date_time_format='%y-%M-%d %H:%M:%S'

def date_time_str(date_time):
    return datetime.strftime(date_time,date_time_format)

def loop(n_loop,n_sec):
    print('线程(',n_loop,')开始执行:',date_time_str(datetime.now()),',先休眠(',n_sec,')秒')
    sleep(n_sec)
    print('线程(',n_loop,')休眠结束，结束于:',date_time_str(datetime.now()))

def main():
    print('---所有线程开始执行:',date_time_str(datetime.now()))
    threads=[]
    n_loops=range(len(loops))

    for i in n_loops:
        t=threading.Thread(target=loop,args=(i,loops[i]))
        threads.append(t)

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

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

    print('---所有线程执行结束于:',date_time_str(datetime.now()))

if __name__=='__main__':
    main()

#执行结果如下：

D:\Pythonworkspace>python threading_thread.py
---所有线程开始执行: 18-31-30 09:31:54
线程( 0 )开始执行: 18-31-30 09:31:54 ,先休眠( 4 )秒
线程( 1 )开始执行: 18-31-30 09:31:54 ,先休眠( 2 )秒
线程( 1 )休眠结束，结束于: 18-31-30 09:31:56
线程( 0 )休眠结束，结束于: 18-31-30 09:31:58
---所有线程执行结束于: 18-31-30 09:31:58

#由执行结果我们看到，实例化一个Thread（调用Thread()）与调用_thread.start_new_thread()最大的区别是新的线程不会立即开始。创建线程对象却不想马上开始运行线程时，Thread是一个很有用的同步特性。所有线程都创建之后，再一起调用start()函数启动，而不是每创建一个线程就启动。而且不用管理一堆锁的状态（分配锁、获得锁、释放锁、检查锁的等状态），只要简单对每个线程调用join()主线程，等待子线程结束即可。join()还可以设置timeout参数，即主线程的超时时间。

#join()的另一个比较重要的方面是可以完全不用调用。一旦线程启动，就会一直运行，直到线程的函数结束并退出为止。如果主线程除了等线程结束外，还有其他事情要做，就不用调用join()，只有在等待线程结束时才调用。

#我们再看示例，创建一个Thread的实例，并传给它一个可调用的类对象。代码如下：

#!/usr/bin/python3
#-*-coding:UTF-8-*-
#threading_join()

import threading
from time import sleep
from datetime import datetime

loops=[4,2]
date_time_format='%y-%M-%d %H:%M:%S'

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 date_time_str(date_time):
    return datetime.strftime(date_time,date_time_format)

def loop(n_loop,n_sec):
    print('线程(',n_loop,')开始执行:',date_time_str(datetime.now()),',先休眠(',n_sec,')秒')
    sleep(n_sec)
    print('线程(',n_loop,')休眠结束，结束于:',date_time_str(datetime.now()))

def main():
    print('---所有线程开始执行:',date_time_str(datetime.now()))
    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 all threads
        threads[i].start()

    for i in nloops:    #wait for completion
        threads[i].join()

    print('---所有线程执行结束于:',date_time_str(datetime.now()))

if __name__=='__main__':
    main()

#执行结果如下：

D:\Pythonworkspace>python threading_join().py
---所有线程开始执行: 18-30-30 11:30:26
线程( 0 )开始执行: 18-30-30 11:30:26 ,先休眠( 4 )秒
线程( 1 )开始执行: 18-30-30 11:30:26 ,先休眠( 2 )秒
线程( 1 )休眠结束，结束于: 18-30-30 11:30:28
线程( 0 )休眠结束，结束于: 18-30-30 11:30:30
---所有线程执行结束于: 18-30-30 11:30:30

#由执行结果看到，与传一个函数很相似的一个方法是，在创建线程时，传一个可调用的类的实例供线程启动时执行，这是多线程编程的一个面向对象的方法。相对于一个或多个函数来说，类对象可以使用类的强大功能。创建线程时，Thread对象会调用ThreadFunc对象，这时会用到一个特殊函数__call__()。由于已经有了要用的参数，因此不用再传到Thread()的构造函数中。对于一个参数的元组，要使用self.func(*self.args)方法。

#从Thread派生一个子类，创建这个子类的实例，从上面的代码派生的代码如下：

#!/usr/bin/python3
#-*-coding:UTF-8-*-
#threading___call__

import threading
from time import sleep
from datetime import datetime

loops=[4,2]
date_time_format='%y-%M-%d %H:%M:%S'

class MyThread(threading.Thread):
    def __init__(self,func,args,name=''):
        threading.Thread.__init__(self)
        self.name=name
        self.func=func
        self.args=args

    def getResult(self):
        return self.res

    def run(self):
        print('starting',self.name,'at:',date_time_str(datetime.now()))
        self.res=self.func(*self.args)
        print(self.name,'finished at:',date_time_str(datetime.now()))

def date_time_str(date_time):
    return datetime.strftime(date_time,date_time_format)

def loop(n_loop,n_sec):
    print('线程(',n_loop,')开始执行:',date_time_str(datetime.now()),',先休眠(',n_sec,')秒')
    sleep(n_sec)
    print('线程(',n_loop,')休眠结束，结束于:',date_time_str(datetime.now()))

def main():
    print('---所有线程开始执行:',date_time_str(datetime.now()))
    threads=[]
    n_loops=range(len(loops))

    for i in n_loops:
        t=MyThread(loop,(i,loops[i]),loop.__name__)
        threads.append(t)

    for i in n_loops:
        threads[i].start()

    for i in n_loops:
        threads[i].join()

    print('---所有线程执行结束于:',date_time_str(datetime.now()))

if __name__=='__main__':
    main()

#执行结果如下：

D:\Pythonworkspace>python threading_call.py
---所有线程开始执行: 18-12-30 15:12:55
starting loop at: 18-12-30 15:12:55
线程( 0 )开始执行: 18-12-30 15:12:55 ,先休眠( 4 )秒
starting loop at: 18-12-30 15:12:55
线程( 1 )开始执行: 18-12-30 15:12:55 ,先休眠( 2 )秒
线程( 1 )休眠结束，结束于: 18-12-30 15:12:57
loop finished at: 18-12-30 15:12:57
线程( 0 )休眠结束，结束于: 18-12-30 15:12:59
loop finished at: 18-12-30 15:12:59
---所有线程执行结束于: 18-12-30 15:12:59

#由代码片段和执行结果我们看到，子类化Thread，MyThread子类的构造函数一定要先调用基类的构造函数，特殊函数__call__()在子类中，名字要改为run()。在Thread类中，加入一些用于调试的输出信息，把代码保存到MyThread模块中，并导入这个类。使用self.func()函数运行这些函数，并把结果保存到实现的self.res属性中，创建一个新函数getResult()得到结果。