上一篇博文介绍了Python中线程、进程与协程的基本概念，通过这几天的学习总结，下面来讲讲Python的threading模块。首先来看看threading模块有哪些方法和类吧。

主要有：

Thread ：线程类，这是用的最多的一个类，可以指定线程函数执行或者继承自它都可以实现子线程功能。

Timer：与Thread类似，但要等待一段时间后才开始运行，是Thread的子类。

Lock ：原锁，是一个同步原语，当它锁住时不归某个特定的线程所有，这个可以对全局变量互斥时使用。

RLock ：可重入锁，使单线程可以再次获得已经获得的锁，即可以被相同的线程获得多次。

Condition ：条件变量，能让一个线程停下来，等待其他线程满足某个“条件”。

Event：事件对象，是线程间最简单的通信机制之一：线程可以激活在一个事件对象上等待的其他线程。

Semaphore：信号量对象，是个变量，管理一个内置的计数器,指定可同时访问资源或者进入临界区的线程数。

BoundedSemaphore ：有界信号量对象，与semaphore类似，但不允许超过初始值；

ThreadError：线程错误信息类。

active_count()和activeCount()：返回当前活着的Thread对象个数。

current_thread()和currentThread()：返回当前的Thread对象，对应于调用者控制的线程。如果调用者控制的线程不是通过threading模块创建的，则返回一个只有有限功能的虚假线程对象。

enumerate()：返回当前活着的Thread对象的列表。该列表包括守护线程、由current_thread()创建的虚假线程对象和主线程。它不包括终止的线程和还没有开始的线程。

settrace(func)：为所有从threading模块启动的线程设置一个跟踪函数。在每个线程的run()方法调用之前，func将传递给sys.settrace()（该函数是设置系统的跟踪函数）。

setprofile(func)：为所有从threading模块启动的线程设置一个profile函数。在每个线程的run()调用之前，func将传递给sys.setprofile()（这个函数用于设置系统的探查函数）。

stack_size([size])：返回创建新的线程时该线程使用的栈的大小，

可选的size参数指定后来创建的线程使用栈的大小，它必须是0（使用平台的或者配置的默认值）或不少于32,768(32kB)的正整数。

其它一些以"_"开头的，有些是引入其它模块的函数，然后起了个别名，比如_format_exc，它的定义如下：

from traceback import format_exc as _format_exc

有些其实是类，比如RLock的定义如下：

def RLock(*args, **kwargs):
    """Factory function that returns a new reentrant lock.

    A reentrant lock must be released by the thread that acquired it. Once a
    thread has acquired a reentrant lock, the same thread may acquire it again
    without blocking; the thread must release it once for each time it has
    acquired it.

    """
    return _RLock(*args, **kwargs)

_RLock其实是个类，内部调用的类，RLock其实是个函数，返回一个类，感兴趣的可以去看看threading.py相关代码。

    由于篇幅比较长，只介绍了Thread,Lock,RLock,Condition，不正之处欢迎批评指正，当然更希望大家有耐心、仔细看完，同时能实践一下示例并仔细体会。

（一）Thread对象

    这个类表示在单独的一个控制线程中运行的一个活动。有两种创建方法：创建线程要执行的函数，把这个函数传递进Thread对象里，让它来执行；而是从Thread类中继承，然后在子类中覆盖run()方法，在子类中不应该覆盖其它方法（__init__()除外），也就是只覆盖该类的__init__()和run()方法。

Thread类主要方法：

start()：开始线程的活动。每个线程对象必须只能调用它一次。

run()：表示线程活动的方法，可以在子类中覆盖这个方法。

join([timeout])：是用来阻塞当前上下文，直至该线程运行结束，一个线程可以被join()多次，timeout单位是秒。

name：一个字符串，只用于标识的目的。它没有语义。多个线程可以被赋予相同的名字。初始的名字通过构造函数设置。

getName()/setName()：作用于name的两个函数，从字面就知道是干嘛的，一个是获取线程名，一个是设置线程名

ident：线程的ID，如果线程还未启动则为None，它是一个非零的整数当一个线程退出另外一个线程创建时，线程的ID可以重用，即使在线程退出后，其ID仍然可以访问。

is_alive()/isAlive()：判断线程是否还活着。

daemon：一个布尔值，指示线程是(True)否(False)是一个守护线程。它必须在调用start()之前设置，否则会引发RuntimeError。它的初始值继承自创建它的线程；主线程不是一个守护线程，所以在主线程中创建的所有线程默认daemon = False。

    何为守护线程？举个例子，在程序运行中，执行一个主线程，如果主线程又创建一个子线程，主线程和子线程就分兵两路，当主线程完成想退出时，会检验子线程是否完成。 对于普通线程，如果子线程的任务没有结束，主线程不会退出，整个程序也不会退出；对于守护线程，即使子线程任务还没有结束，如果主线程退出该线程也会退出。

isDaemon()/setDaemon()：作用与daemon的函数，一个是判断是不是守护线程，一个是设置守护线程。

下面通过简单的例子来展示Thread的使用方法，希望对你理解能有帮助，当然更希望你能动手操作下，了解上面方法的用处。

将函数传递到Thread对象

#coding=utf-8
import threading
import datetime
import time
def thread_fun(num):
    time.sleep(num)
    now = datetime.datetime.now()
    print "线程名:%s ,now is %s"          %( threading.currentThread().getName(), now)

def main(thread_num):
    thread_list = list()
    # 先创建线程对象
    for i in range(0, thread_num):
        thread_name = "thread_%s" %i
        thread_list.append(threading.Thread(target = thread_fun, name = thread_name, args = (2,)))

    # 启动所有线程
    for thread in thread_list:
        thread.setName("good")#修改线程名
        print thread.is_alive()#判断线程是否是活的
        print thread.ident
        thread.start()
        print thread.ident
        print thread.is_alive()
        thread.join()
        print thread.is_alive()

if __name__ == "__main__":
    main(3)

运行结果如下：

上面的例子只是展示了几个简单的Thread类的方法，其它方法大家可以自己动手试试，体会下。这里再讲下threading.Thread()

它的原型是：

class threading.Thread(group=None, target=None, name=None, args=(), kwargs={})

group应该为None；被保留用于未来实现了ThreadGroup类时的扩展。

target是将被run()方法调用的可调用对象。默认为None，表示不调用任何东西。

name是线程的名字。默认情况下，以“Thread-N”的形式构造一个唯一的名字，N是一个小的十进制整数。

args是给调用目标的参数元组。默认为()。

kwargs是给调用目标的关键字参数的一个字典。默认为{}。

继承自threading.Thread类:

继承的话，主要是重定义__init__()和run()。

#coding=utf-8
import threading

class MyThread(threading.Thread):
    def __init__(self,group=None,target=None,name=None,args=(),kwargs=None):
        threading.Thread.__init__(self,group,target,name,args,kwargs)

        self.name = "Thread_%s"%threading.active_count()

    def run(self):
        print  "I am %s" %self.name


if __name__ == "__main__":

    for thread in range(0, 5):
        t = MyThread()
        t.start()

运行结果就不贴出来了。

（二）Lock互斥锁

    如果多个线程访问同时同一个资源，那么就有可能对这个资源的安全性造成破坏，还好Python的threading模块中引入了互斥锁对象，可以保证共享数据操作的完整性。每个对象都对应于一个可称为” 互斥锁” 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象这时候可以使用threading模块提供的Lock类。它主要有两个方法：acquire()和 release()

acquire(blocking=True, timeout=-1)

    获取锁,设置为locked状态，blocking参数表示是否阻塞当前线程等待，timeout表示阻塞时的等待时间 。如果成功地获得lock，则acquire()函数返回True，否则返回False，timeout超时时如果还没有获得lock仍然返回False。

release（）

    释放锁，设置为unlocked状态，当在未锁定的锁上调用时，会引发ThreadError。没有返回值。

下面的代码是没有设锁时，100个线程访问一个资源，从运行结果来看对资源的完整性造成了一定的影响。

#coding=utf-8
import threading
import time
num = 0
class MyThread(threading.Thread):
    def __init__(self,target=None,name=None,args=(),kwargs=None):
        threading.Thread.__init__(self,target=target,name=name,args=args,kwargs=kwargs)
    def run(self):
        global num
        time.sleep(1)#这句不能少，要不然看不到对公共资源完整性的破坏，当然也可以将该句放在
        #num += 1的后面，有兴趣可以试试
        num += 1
        self.setName("Thread-%s" % num)
        print("I am %s, set counter:%s" % (self.name, num))
if __name__ == "__main__":
    for i in range(0, 100):
        my_thread = MyThread()
        my_thread.start()

运行结果如下：

看看部分数据的完整性遭到了“破坏”

再看看使用互斥锁的例子

#coding=utf-8
import threading
import time
num = 0
lock = threading.Lock()
class MyThread(threading.Thread):
    def __init__(self,target=None,name=None,args=(),kwargs=None):
        threading.Thread.__init__(self,target=target,name=name,args=args,kwargs=kwargs)
    def run(self):
        global num
        time.sleep(1)
        if lock.acquire():
            num += 1
            self.setName("Thread-%s" % num)
        print("I am %s, set counter:%s" % (self.name, num))
        lock.release()
if __name__ == "__main__":
    for i in range(0, 100):
        my_thread = MyThread()
        my_thread.start()

运行结果大家可以动手试试。

同步阻塞

    当一个线程调用Lock对象的acquire()方法获得锁时，这把锁就进入“locked”状态。因为每次只有一个线程可以获得锁，所以如果此时另一个线程试图获得这个锁，该线程就会变为“block“同步阻塞状态。直到拥有锁的线程调用锁的release()方法释放锁之后，该锁进入“unlocked”状态。线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行状态。

死锁

是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程

（三）可重入锁RLock

用法和Lock用法一样，只RLock支持嵌套，而Lock不支持嵌套；RLock允许在同一线程中被多次acquire（如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的琐），而Lock却不允许这种情况，否则会出现死锁。看下面例子：

#coding=utf-8
import threading
import time
num = 0
lock = threading.Lock()
class MyThread(threading.Thread):
    def __init__(self,target=None,name=None,args=(),kwargs=None):
        threading.Thread.__init__(self,target=target,name=name,args=args,kwargs=kwargs)
    def run(self):
        global num
        time.sleep(1)
        if lock.acquire():
            num += 1
            self.setName("Thread-%s" % num)
            print("I am %s, set counter:%s" % (self.name, num))
            if lock.acquire():
                num += 1
                self.setName("Thread-%s" % num)
                print("I am %s, set counter:%s" % (self.name, num))
            lock.release()

        lock.release()
if __name__ == "__main__":
    for i in range(0, 100):
        my_thread = MyThread()
        my_thread.start()

上面的例子使用Lock锁嵌套使用，运行后就出现了死锁，运行不下去，“卡住了”。

这个时候就出现了RLock,它支持在同一线程中可以多次请求同一资源。RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。所以将上面的代码中

lock = threading.Lock()

改为

lock = threading.RLock()

就不会出现死锁情况。

（四）条件变量Condition

        除了互斥锁外，对复杂线程同步问题，Python提供了Condition对象来支持解决。Condition被称为条件变量，除了提供与Lock类似的acquire和release方法外，还提供了wait和notify方法。线程首先acquire一个条件变量，然后判断一些条件。如果条件不满足则wait；如果条件满足，进行一些处理改变条件后，通过notify方法通知其他线程，其他处于wait状态的线程接到通知后会重新判断条件。不断的重复这一过程，从而解决复杂的同步问题。

除了acquire和release方法外还有如下方法：

wait([timeout]):  

　　w释放内部所占用的琐，同时线程被挂起，直至接收到通知被唤醒或超时（如果提供了timeout参数的话）。当线程被唤醒并重新占有琐的时候，程序才会继续执行下去。

notify():

　　唤醒一个挂起的线程（如果存在挂起的线程），该方法不会释放所占用的琐。

notify_all()/notifyAll()

　　唤醒所有挂起的线程（如果存在挂起的线程），这些方法不会释放所占用的琐。

同时要主要这四个方法只有在占用琐(acquire)之后才能调用，否则将会报RuntimeError异常。

    Condition其实是一把高级的锁，它内部维护着一个锁对象（默认是RLock），当然你也可以通过它的构造函数传递一个Lock/RLock对象给它。我们可以看看它的__init__()函数的定义：

def __init__(self, lock=None, verbose=None):
        _Verbose.__init__(self, verbose)
        if lock is None:
            lock = RLock()
        self.__lock = lock
        # Export the lock‘s acquire() and release() methods
        self.acquire = lock.acquire
        self.release = lock.release
        # If the lock defines _release_save() and/or _acquire_restore(),
        # these override the default implementations (which just call
        # release() and acquire() on the lock).  Ditto for _is_owned().
        try:
            self._release_save = lock._release_save
        except AttributeError:
            pass
        try:
            self._acquire_restore = lock._acquire_restore
        except AttributeError:
            pass
        try:
            self._is_owned = lock._is_owned
        except AttributeError:
            pass
        self.__waiters = []

是不是一目了然。条件变量的经典问题就是生产者与消费者的例子了。假设某代工厂的两个车间，一个车间生产某种配件,另一个车间需要这些配件进行组装产品，那么前者就是生产者(Producer)，后者就是消费者(Consumer),当配件数低于1000就需要生产，多余5000个可以暂停生产，生产者一秒中可生产200个，消费者的策略是剩余数量少于800就不组装了，一秒钟可消费100个。代码如下

#coding=utf-8
import threading
import time
left_num = 500#假设初始剩余数为500
con = threading.Condition()

class Producer(threading.Thread):
    """生产者"""
    def __init__(self, target=None, name=None, args=(), kwargs=None):
        threading.Thread.__init__(self, target=target, name=name, args=args, kwargs=kwargs)
    def run(self):
        global left_num
        is_product = True
        while True:
            if con.acquire():
                if left_num > 5000:#大于5000可以暂停生产
                    is_product = False#不用继续生产
                    con.wait()#该“生产线”挂起
                elif left_num < 1000:
                    is_product = True#继续生产
                    left_num += 200
                    msg = self.name+‘ produce 200, left_num=%s‘%left_num
                    print msg
                    con.notify()
                else:
                    #对于剩余数量处在中间的，就要分情况讨论了，一旦开启“生产”就要等
                    #到生产到指定数目才能停止，仔细想想很好理解的
                    if is_product:
                        left_num += 200
                        msg = self.name + ‘ produce 200, left_num=%s‘ % left_num
                        print msg
                        con.notify()
                    else:
                        con.wait()
                con.release()
                time.sleep(1)

class Consumer(threading.Thread):
    """消费者"""
    def __init__(self, target=None, name=None, args=(), kwargs=None):
        threading.Thread.__init__(self, target=target, name=name, args=args, kwargs=kwargs)
    def run(self):
        global left_num
        while True:
            if con.acquire():
                if left_num < 800:#少于800不组装
                    con.wait()
                else:
                    left_num -= 100
                    msg = self.name+‘ consume 100, left_num=%s‘%left_num
                    print msg
                    con.notify()
                con.release()
                time.sleep(1)


def test():
    for i in range(1):
        p = Producer()
        p.start()
    for i in range(1):
        c = Consumer()
        c.start()
if __name__ == ‘__main__‘:
    test()

        大家可以把代码复制下来运行看看，仔细体会下，当累计剩余数大于5000后，就停止了“生产",之后只有消费者在运作，当剩余数低于1000，生产者”生成线"重启生产，直到累计剩余数大于5000，后又停止生产，以此类推。示例中展示的都是生产者与消费者都只有一条”流水线”，实际上，生产者有多条”流水线",消费者也有多条"流水线“，其实都一样，将上面代码的for循环的范围改下就可以了。还有一点，Condition可以接受一个Lock/RLock对象，大家可以试试创建一个Lock/RLock传递给Condition，如下：

lock = threading.Lock()
con = threading.Condition(lock)

效果是一样的，大家可以动手试试。

Python：线程、进程与协程(2)——threading模块(1)