python的线程锁机制_dominic

python的线程锁机制_dominic_80ChinaUnix博客

python的线程锁机制
(2011-03-23 15:17)
标签:
python 线程锁
分类： PYTHON


线程与锁


请求锁定 -- 进入锁定池等待 -- 获取锁 --- 已锁定 --- 释放锁



锁
Lock()

Lock（指令锁）是可用的最低级的同步指令。Lock处于锁定状态时，不被特定的线程拥有。Lock包含两种状态——锁定和非锁定，以及两个基本的方法。
可以认为Lock有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。
构造方法：
Lock()
实例方法：
acquire([timeout]): 使线程进入同步阻塞状态，尝试获得锁定。
release(): 释放锁。使用前线程必须已获得锁定，否则将抛出异常。

实例程序:

#!/usr/bin/env python
import threading
import time
data = 0
lock = threading.Lock()
def fun():
        global data
        print "%s acquire lock..."% threading.currentThread().getName()
        if lock.acquire(): #等待获取锁，如果获取成功，开始锁定并进行操作
                print '%s get the lock.' % threading.currentThread().getName()
                data += 1
                print data
                time.sleep(1)
                print '%s release lock...' % threading.currentThread().getName()
                lock.release() #释放锁
t1 = threading.Thread(target=fun)
t2 = threading.Thread(target=fun)
t3 = threading.Thread(target=fun)
t1.start()
t2.start()
t3.start()

以上代码，当线程t1锁释放后线程t2才能进行锁定。同样道理，等t2锁释放，t3才能进行锁定，但t2、t3会在t1一起进入等待锁获取状态。


重入锁
RLock()
RLock（可重入锁）是一个可以被同一个线程请求多次的同步指令。RLock使用了“拥有的线程”和“递归等级”的概念，处于锁定状态时，RLock被某个线程拥有。拥有RLock的线程可以再次调用acquire()，释放锁时需要调用release()相同次数。
可以认为RLock包含一个锁定池和一个初始值为0的计数器，每次成功调用 acquire()/release()，计数器将+1/-1，为0时锁处于未锁定状态。
构造方法：
RLock()
实例方法：
acquire([timeout])/release(): 跟Lock差不多。

实例程序:

#!/usr/bin/env python
import threading
import time
data = 0
lock = threading.RLock()
def fun():
        global data
        print "%s acquire lock..."% threading.currentThread().getName()
        if lock.acquire(): #等待获取锁，如果获取成功，开始锁定并进行操作
                print '%s get the lock.' % threading.currentThread().getName()
                data += 1
                print data
                time.sleep(2)
                print '%s get the lock again.' % threading.currentThread().getName()
                if lock.acquire(): #再次获取并，如果获取成功，开始锁定并进行操作
                        data += 1
                        print data
                        time.sleep(2)
                print '%s release lock...' % threading.currentThread().getName()
                lock.release() #释放锁
                time.sleep(1)
                print '%s release lock again...' % threading.currentThread().getName()
                lock.release() #释放锁
t1 = threading.Thread(target=fun)
t2 = threading.Thread(target=fun)
t3 = threading.Thread(target=fun)
t1.start()
t2.start()
t3.start()



以上代码，当线程t1两次请求的锁都释放后线程t2才能进行锁定。同样道理，等t2两次请求的锁释放后，t3才能进行锁定，但t2、t3会同t1一起进入等锁获取状态。
博客推荐文章
Python 常见算法操作（3） (2小时前)
thrift 解析小工具 & nginx+lua 扩展使用（四） (2小时前)
重庆著名律师阐述报应主义刑法与预防主义刑法 (3小时前)
上海律师法律咨询讲述交通事故赔偿时应注意的方面 (3小时前)
Perl钻石操作符输入 (5小时前)