python的线程锁机制_dominic_80-ChinaUnix博客

python的线程锁机制_dominic_80-ChinaUnix博客

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小时前)