python 多线程-threading模块

Threading模块

 python提供了两个模块来实现多线程thread 和threading ，thread 有一些缺点，在threading 得到了弥补，为了不浪费你和时间，现在介绍更高级的threading模块。除了Thread类，该模块还包括许多好用的同步机制。

 下表给出了threading模块中所有可用对象的列表。

对象	描述
Thread	表示一个执行线程的对象
Lock	锁原语对象（和thread模块中的锁一样）
Rlock	可重入锁对象，使单一线程可以（再次）获得已持有的锁（递归锁）
Condition	条件变量对象，使得一个线程等待另一个线程满足特定的“条件”，比如改变状态或某个数据值
Event	条件变量的通用版本，任意数量的线程等待某个时间的发生，在该事件发生后所有线程将被**
Semaphore	为线程间共享的有限资源提供了一个计数器，如果没有可用资源时会被阻塞
BoundedSemaphore	与Semaphore相似，不过它不允许超过初始值
Timer	与Thread相似，不过它要在运行前等待一段时间
Barrier	创建一个“障碍”，必须达到指定数量的线路后才可以继续

  避免使用thread模块的另一个原因是该模块不支持守护线程这个概念，当主线程退出时，所有子线程都将终止，不管它们是否仍在工作。如果你不希望发生这种行为，就要引入守护线程的概念了。

 要将一个线程设置为守护线程，需要在启动线程之前执行如下赋值语句：thread.daemon=True(调用thread.setDaemon(True)的旧方法已经弃用了)。同样，要检查线程的守护状态，也只需要检查这个值即可(对比过去调用thread.isDaemon()的方法)。一个新的子线程会继承父线程的守护标记。

Thread类

 threading模块的Thread类是主要的执行对象。它有thread模块中没有的很多函数。

 下表给出了它的属性和方法列表

属性	描述
Thread对象数据属性
name	线程名
ident	线程的标识符
daemon	布尔标志，表示这个线程是否是守护线程
Thread对象方法
__init__(group=None,target=None,name=None,args=(),kwargs={},verbose=None,daemon=None)	实例化一个线程对象，需要一个可调用的target，以及其参数args或kwargs。还可以传递name或group参数，不过后者还示实现。些外，verbose标志也是可接受的。而daemon的值将会设定thread.daemon属性/标志
start()	开始执行该线程
run()	定义线程功能的方法（通常在子类中被应用开发者重写）
join(timeout=None)	直至启动的线程终止之前一直挂起；除非给出了timeout(秒)，否则会一直阻塞
is_alive()	isAlivel(已经弃用)，布尔标志，表示这个线程是否还存活

使用Thread类，可以有多种方法来创建线程。

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

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

• 派生Thread的子类，并创建子类的实例

 通常会选择第一个或第三个方案。当你需要一个更加符合面向对象的接口时，你会选择后者，否则会选择前者。第二种方案有些扯淡，暂时不做介绍。

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

使threading模块

 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))

    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[i].join() # threads to finish

    print('all DONE at:',ctime())

if __name__ == '__main__':
    main()

执行结果：

starting at: Sun Jan  8 18:07:28 2017
start loop 0 at: Sun Jan  8 18:07:28 2017
start loop 1 at: Sun Jan  8 18:07:28 2017
loop 1 done at: Sun Jan  8 18:07:30 2017
loop 0 done at: Sun Jan  8 18:07:32 2017
all DONE at: Sun Jan  8 18:07:32 2017

  当实例化Thread对象时，把函数(target)和参数(args)传进去，然后得到返回的Thread实例。实例化Thread（调用Thread()）时，新线程不会立即执行。这是一个非常有用的同步功能，尤其是当你并不希望线程立即开始执行时。

  当所有线程都分配完成之后，通过调用每个线程的start()方法让它们开始执行，而不是在这之前执行。相比于管理一组锁（分配，获取，释放，检查锁状态等）而言，这里只需要为每个线程调用join()方法即可。join()方法将等待线程结束，或者在提供了超时时间的情况下，达到超时时间，使用join()方法要比等待锁释放的无限循环更加清晰。

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

派生Thread的子类，并创建子类的实例

下面的这个例子要调用Thread()的子类，当创建线程时使用子类要相对更容易阅读。

子类化的Thread

 本例中将对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.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 = 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()

执行结果：

starting at: Sun Jan  8 18:38:21 2017
start loop 0 at: Sun Jan  8 18:38:21 2017
start loop 1 at: Sun Jan  8 18:38:21 2017
loop 1 done at: Sun Jan  8 18:38:23 2017
loop 0 done at: Sun Jan  8 18:38:25 2017
all DONE at: Sun Jan  8 18:38:25 2017

注意：MyThread子类的构造函数必须先调用其基类的构造函数，重写run()方法

 现在，对MyThrea类进行修改，增加一些调试信息的输出，并将其存储为一个名为myThread的独立模块。除了简单地调用函数外，还将把结果保存在实例属性self.res中，并创建一个新的方法getResult()来获取这个值。

import threading
from time import ctime

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:',ctime())
        self.res = self.func(*self.args)
        print( self.name, 'finished at:', ctime())

Threading模块的其他函数

除了各种同步和线程对象外，threading模块还提供了一些函数，如下表所示：

函数	描述
active_count()	当前活动的Thread对象个数
current_thread	返回当前的Thread对象
enumerate()	返回当前活动的Thread对象列表
settace(func)	为所有线程设置一个trace函数
setprofile(func)	为所有线程设置一个profile函数
stack_size(size=0)	返回新创建线程的栈大小；或为后续创建的线程设定栈的大小为size