进程、线程、协程（三） 多线程实现

Threading 是Tread的封装。一般调用多线程库都会调用Threading模块。

Threading模块提供的类：Thread，Lock，Rlock，Condition, Semaphore, Event, Timer, local。

threading 模块提供的实例方法： 
threading.currentThread(): 返回当前的线程变量。 
threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。 
threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

threading模块低筒的实例属性：

threading.TIMEOUT_MAX：设置threading全局超时时间。

 

1、Thread

Thread创建线程实例。

构造方法：

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

参数解释：
　　group: 线程组，目前还没有实现，库引用中提示必须是None
　　target: 要执行的方法
　　name: 线程名
　　args/kwargs: 要传入方法的参数

实例方法：

isAlive()：线程是否在运行。若是返回True，否则False。

getName()：获取线程名。

setName(name)：设置线程名。 

isDaemon()：是否守护线程。

setDaemon(bool)：设置是守护线程（默认False）。在start之前设置。若为True，主线程执行完，子线程没执行完也会结束。

start()：启动线程。 

join(timeout)： 阻塞当前上下文环境的线程，直到调用此方法的线程终止或到达指定的timeout值（可选参数）。

import time
from threading import Thread

def f1(number):
    time.sleep(2)
    print "the thread number is: %s" % number

if __name__ == "__main__":
    print "main thread start"
    for i in xrange(10):
        t = Thread(target=f1, args=(i, ))
        # t.setDaemon(True) 打开或关闭守护线程
        t.start()
    print "main thread end"

 

2、Lock，Rlock

Lock和Rlock基本功能相同，都是为了多个线程同时操作一个内存中的资源时不产生混乱。

但是Lock多次acquire()会产生死锁，而Rlock可以多次acquire()。RLock使用了“拥有的线程”和“递归等级”的概念，处于锁定状态时，RLock被某个线程拥有。拥有RLock的线程可以再次调用acquire()，释放锁时需要调用release()相同次数，即用了几次acquire就有多少次release()。

实例方法：

acquire(blocking=True, timeout=-1)：尝试获得锁定。blocking参数表示是否阻塞当前线程等待，timeout表示阻塞时的等待时间 。如果成功地获得lock，则acquire()函数返回True，否则返回False，timeout超时时如果还没有获得lock仍然返回False。

release()：释放锁。使用前线程必须已获得锁定，否则将抛出异常。

 

3、condition

Condition（条件变量）通常与一个锁关联。需要在多个Contidion中共享一个锁时，可以传递一个Lock/RLock实例给构造方法，否则它将自己生成一个RLock实例。

构造方法：

Condition([lock/rlock])

实例方法：

acquire(blocking=True, timeout=-1)： 尝试获得锁定。

wait([timeout])：调用这个方法将使线程进入Condition的等待池等待通知，并释放锁。使用前线程必须已获得锁定，否则将抛出异常。 

notify()：调用这个方法将从等待池挑选一个线程并通知，收到通知的线程将自动调用acquire()尝试获得锁定（进入锁定池）；其他线程仍然在等待池中。调用这个方法不会释放锁定。使用前线程必须已获得锁定，否则将抛出异常。 

notifyAll():：调用这个方法将通知等待池中所有的线程，这些线程都将进入锁定池尝试获得锁定。调用这个方法不会释放锁定。使用前线程必须已获得锁定，否则将抛出异常。

通过条件变量，两个线程交互，一问一答。

import time
from threading import Thread, Condition

def Tom(con, name):
    time.sleep(2)
    con.acquire()
    print "%s: Hi!" % name
    con.notify()
    con.wait()
    print "%s: How are you?" % name
    con.notify()
    con.release()


def Bob(con, name):
    con.acquire()
    con.wait()
    print "%s: hi!" % name
    con.notify()
    con.wait()
    print "%s: I am fine, thanks." % name
    con.release()

if __name__ == "__main__":
    print "main thread start"
    con = Condition()
    tom = Thread(target=Tom, args=(con, "Tom"))
    bob = Thread(target=Bob, args=(con, "Bob"))
    tom.start()
    bob.start()
    print "main thread end"

输出：
main thread start
main thread end
Tom: Hi!
Bob: hi!
Tom: How are you?
Bob: I am fine, thanks.

 

4、Semaphore 

Semaphore 在内部管理着一个计数器。调用 acquire() 会使这个计数器 -1，release() 则是+1(可以多次release()，所以计数器的值理论上可以无限).计数器的值永远不会小于 0，当计数器到 0 时，再调用 acquire() 就会阻塞，直到其他线程来调用release()。

构造方法：

Semaphore([value])：

参数解释：
value：计数器的值

其用法与Lock相似。

 

5、Event 

一个线程通知事件，其他线程等待事件。Event内置了一个初始为False的标志，当调用set()时设为True，调用clear()时重置为 False。wait()将阻塞线程至等待阻塞状态。

Event其实就是一个简化版的 Condition。Event没有锁，无法使线程进入同步阻塞状态。

实例方法： 
isSet()： 当内置标志为True时返回True。 
set()： 将标志设为True，并通知所有处于等待阻塞状态的线程恢复运行状态。 
clear()： 将标志设为False。 
wait([timeout])： 如果标志为True将立即返回，否则阻塞线程至等待阻塞状态，等待其他线程调用set()。

import time
from threading import Thread, Event, currentThread

def f1():
    event.wait()
    print '%s recv event.' % currentThread().getName()

if __name__ == "__main__":
    print "main thread start"
    event = Event()
    t1 = Thread(target=f1)
    t2 = Thread(target=f1)
    t1.start()
    t2.start()
    event.set()
    print "main thread end\n"

输出：
main thread start
main thread end
Thread-2 recv event.
Thread-1 recv event.

 

6、Timer

Timer（定时器）是Thread的派生类，用于在指定时间后调用一个方法。

构造方法： 

Timer(interval, function, args=[], kwargs={}) ：

参数解释：
interval: 指定的时间 
function: 要执行的方法 
args/kwargs: 方法的参数

实例方法与Thread一致。

import time
from threading import Timer

def f1():
    print "into timer function"
if __name__ == "__main__":
    print "main thread start"
    timer = Timer(10, f1)
    timer.start()
    print "main thread end\n"

输出：
main thread start
main thread end

into timer function

 

7、local

local是一个小写字母开头的类，用于管理 thread-local（线程局部的）数据。对于同一个local，线程无法访问其他线程设置的属性；线程设置的属性不会被其他线程设置的同名属性替换。