Python多线程（2）——线程同步机制

　　本文介绍Python中的线程同步对象，主要涉及 thread 和 threading 模块。

　　threading 模块提供的线程同步原语包括：Lock、RLock、Condition、Event、Semaphore等对象。

1. Lock

1.1 Lock对象的建立

　　Lock是Python中最底层的同步机制，直接由底层模块 thread 实现，每一个lock对象只有两种状态——上锁和未上锁，不一样于下文的RLock对象，Lock对象是不可重入的，也没有所属的线程这个概念。

　　能够经过下面两种方式建立一个Lock对象，新建立的 Lock 对象处于未上锁的状态：

thread.allocate_lock()
threading.Lock()

　　但他们本质上都是在 thread 模块中实现的。

例如：

>>> l = threading.Lock()
>>> type(l)
<type 'thread.lock'>
>>> l
<thread.lock object at 0x0000000001C8F190>

　　

1.2 lock对象的方法

　　lock对象提供三种方法：acquire()、locked()和release()

l.acquire(wait=True)

　　该函数须要结合参数 wait 进行讨论：

　　1. 当 wait 是 False 时，若是 l 没有上锁，那么acquire()调用将l上锁，而后返回True；

　　2. 当 wait 是 False 时，若是 l 已经上锁，那么acquire()调用对 l 没有影响，而后返回False；

　　3. 当 wait 是 True 时，若是 l 没有上锁，acquire()调用将其上锁，而后返回True；

　　4. 当 wait 是 True 时，若是 l 已经上锁，此时调用 l.acquire() 的线程将会阻塞，直到其余线程调用 l.release()，这里须要注意的是，就算这个线程是最后一个锁住 l 的线程，只要它以wait=True调用了acquire()，那它就会阻塞，由于Lock原语是不支持重入的。

　　可将，只要 l 没有上锁，调用 acquire()的结果是相同的。当l 上锁了，而 wait=False 时，线程会当即获得一个返回值，不会阻塞在等待锁上面；而 wait = True时，线程会阻塞等待其余的线程释放该锁，因此，一个锁上面可能有多个处于阻塞等待状态的线程。

 

l.locked()

　　判断 l 当前是否上锁，若是上锁，返回True，不然返回False。

 

l.release()

　　解开 l 上的锁，要求：

• 任何线程均可以解开一个已经锁上的Lock对象；
• l 此时必须处于上锁的状态，若是试图 release() 一个 unlocked 的锁，将抛出异常 thread.error。

　　l一旦经过release()解开，以前等待它（调用过 l.acquire()）的全部线程中，只有一个会被当即被唤醒，而后得到这个锁。

 

2. RLock 可重入锁

2.1 RLock对象的建立

　　RLock是可重入锁，提供和lock对象相同的方法，可重入锁的特色是

• 　　记录锁住本身的线程 t ，这样 t 能够屡次调用 acquire() 方法而不会被阻塞，好比 t 能够屡次声明本身对某个资源的需求。
• 　　可重入锁必须由锁住本身的线程释放（rl.release()）
• 　　rlock内部有一个计数器，只有锁住本身的线程 t 调用的 release() 方法和以前调用 acquire() 方法的次数相同时，才会真正解锁一个rlock。

　　经过：

>>> rl = threading.RLock()

　　能够建立一个可重入锁。

 

2.2 rlock对象的方法

　　rlock()对象提供和Lock对象相同的acquire()和release()方法。

 

3. Condition 条件变量

3.1 Condition 对象的获取

　　condition对象封装了一个lock或rlock对象，经过实例化Condition类来得到一个condition对象：

c = threading.Condition(lock=None)

　　正如前面说的，condition对象的是基于Lock对象RLock对象的，若是建立 condition 对象时没传入 lock 对象，则会新建立一个RLock对象。

 

3.2 Condition 对象的方法

　　Condition对象封装在一个Lock或RLock对象之上，提供的方法有：acquire(wait=1)、release()、notify()、notifyAll()和wait(timeout=None)

c.acquire(wait=1)
c.release()

　　本质上， condition对象的 acquire() 方法和 release() 方法都是底层锁对象的对应方法，在调用condition对象的其余方法以前，都应该确保线程已经拿到了condition对象对应的锁，也就是调用过 acquire()。

 

c.notify()
c.notify_all()

　　notify()唤醒一个等待 c 的线程，notify_all() 则会唤醒全部等待 c 的线程；

　　线程在调用 notify() 和 notifyAll() 以前必须已经得到 c 对应的锁，不然抛出 RuntimeError。

　　notify() 和 notifyAll() 并不会致使线程释放锁，可是notify() 和 notify_all()以后，唤醒了其余的等待线程，当前线程已经准备释放锁，所以线程一般会紧接着调用 release() 释放锁。

 

c.wait(timeout=None)

　　wait()最大的特色是调用wait()的线程必须已经acquire()了 c ，调用wait()将会使这个线程放弃 c，线程在此阻塞，而后当wait()返回时，这个线程每每又拿到了 c 。这个描述比较绕，看一个直观一点的：

　　一个线程想要对临界资源进行操做，首先要得到 c ，得到 c 后，它判断临界资源的状态对不对，发现不对，就调用 wait()放掉手中的 c ，这时候实际上就是在等其余的线程来更新临界资源的状态了。当某个其余的线程修改了临界资源的状态，而后唤醒等待 c 的线程，这时咱们这个线程又拿到 c （假设很幸运地抢到了），就能够继续执行了。

　　若是临界资源一直不对，而咱们这个线程又抢到了 c ，就能够经过一个循环，不断地释放掉不须要的锁，直到临界资源的状态符合咱们的要求。

例如：

# 消费者
cv.acquire()
while not an_item_is_available():
    cv.wait()
get_an_available_item()
cv.release()

# 生产者
cv.acquire()
make_an_item_available()
cv.notify()
cv.release()

　　这个例子中，消费者在产品没有被生产出来以前，就算拿到 c ，也会当即调用 wait() 释放，当产品被生产出来后，生产者唤醒一个消费者，消费者从新回到 wait() 阻塞的地方，发现产品已经就绪，因而消费产品，最后释放 c 。

 

4 Event 事件

4.1 Event 对象的建立

　　Event对象可让任何数量的线程暂停和等待，event 对象对应一个 True 或 False 的状态（flag），刚建立的event对象的状态为False。经过实例化Event类来得到一个event对象：

e = threading.Event()

　　刚建立的event对象 e，它的状态为 False。

 

4.2 Event 对象的方法

e.clear()

　　将 e 的状态设置为 False。

　　

e.set()

　　将 e 的状态设置为 True。

　　此时全部等待 e 的线程都被唤醒进入就绪状态。

 

e.is_set()

　　返回 e 的 状态——True 或 False。

 

e.wait(timeout=None)

　　若是 e 的状态为True，wait()当即返回True，不然线程会阻塞直到超时或者其余的线程调用了e.set()。

 

5. Semaphore 信号量

5.1 Semaphore 对象的建立

　　信号量无疑是线程同步中最经常使用的技术了，信号量是一类通用的锁，锁的状态一般就是真或假，可是信号量有一个初始值，这个值每每反映了固定的资源量。

　　经过调用：

s = threading.Semaphore(n=1)

　　建立一个Python信号量对象，参数 n 指定了信号量的初值。

 

5.2 Semaphore对象的方法

s.acquire(wait=True)

• 当 s 的值 > 0 时，acquire() 会将它的值减 1，同时返回 True。
• 当 s 的值 = 0 时，须要根据参数 wait 的值进行判断：若是wait为True，acquire() 会阻塞调用它的线程，直到有其余的线程调用 release() 为止；若是wait为False，acquire() 会当即返回False，告诉调用本身的线程，当前没有可用的资源。

 

s.release()

• 当 s 的值 > 0 时，release()会直接将 s 的值加一；
• 当 s 的值 = 0 时而当前没有其余等待的线程时，release() 也会将 s 的值加一；
• 当 s 的值 = 0 时而当前有其余等待的线程时，release() 不改变 s 的值（仍是0），唤醒任意一个等待信号量的线程；调用release()的线程继续正常执行。