python的线程锁机制_dominic_80ChinaUnix博客

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

python的线程锁机制_dominic_80ChinaUnix博客

线程与锁

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

锁

Lock()

Lock（指令锁）是可用的最低级的同步指令。Lock处于锁定状态时，不被特定的线程拥有。Lock包含两种状态——锁定和非锁定，以及两个基本的方法。

可以认为Lock有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。

构造方法：
Lock()

实例方法：
acquire([timeout]): 使线程进入同步阻塞状态，尝试获得锁定。
release(): 释放锁。使用前线程必须已获得锁定，否则将抛出异常。

实例程序:

  1. #!/usr/bin/env python
  2. import threading
  3. import time
  4. data = 0
  5. lock = threading.Lock()
  6. def fun():
  7. global data
  8. print "%s acquire lock..."% threading.currentThread().getName()
  9. if lock.acquire(): #等待获取锁，如果获取成功，开始锁定并进行操作
  10. print '%s get the lock.' % threading.currentThread().getName()
  11. data += 1
  12. print data
  13. time.sleep(1)
  14. print '%s release lock...' % threading.currentThread().getName()
  15. lock.release() #释放锁
  16. t1 = threading.Thread(target=fun)
  17. t2 = threading.Thread(target=fun)
  18. t3 = threading.Thread(target=fun)
  19. t1.start()
  20. t2.start()
  21. 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差不多。

实例程序:


  1. #!/usr/bin/env python
  2. import threading
  3. import time
  4. data = 0
  5. lock = threading.RLock()
  6. def fun():
  7. global data
  8. print "%s acquire lock..."% threading.currentThread().getName()
  9. if lock.acquire(): #等待获取锁，如果获取成功，开始锁定并进行操作
  10. print '%s get the lock.' % threading.currentThread().getName()
  11. data += 1
  12. print data
  13. time.sleep(2)
  14. print '%s get the lock again.' % threading.currentThread().getName()
  15. if lock.acquire(): #再次获取并，如果获取成功，开始锁定并进行操作
  16. data += 1
  17. print data
  18. time.sleep(2)
  19. print '%s release lock...' % threading.currentThread().getName()
  20. lock.release() #释放锁
  21. time.sleep(1)
  22. print '%s release lock again...' % threading.currentThread().getName()
  23. lock.release() #释放锁
  24. t1 = threading.Thread(target=fun)
  25. t2 = threading.Thread(target=fun)
  26. t3 = threading.Thread(target=fun)
  27. t1.start()
  28. t2.start()
  29. t3.start()

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

博客推荐文章
  • Python 常见算法操作（3） (2小时前)
  • thrift 解析小工具 & nginx+lua 扩展使用（四） (2小时前)
  • 重庆著名律师阐述 报应主义刑法与预防主义刑法 (3小时前)
  • 上海律师法律咨询讲述交通事故赔偿时应注意的方面 (3小时前)
  • Perl钻石操作符输入 (5小时前)
标签 , ,

发表回复