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信号量对象,参数 指定了信号量的初值。

 

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()的线程继续正常执行。

 

posted @ 2015-08-15 21:38 王智愚 阅读(...) 评论(...) 编辑 收藏