Chinaunix首页 | 论坛 | 博客
  • 博客访问: 282049
  • 博文数量: 59
  • 博客积分: 2941
  • 博客等级: 少校
  • 技术积分: 975
  • 用 户 组: 普通用户
  • 注册时间: 2005-12-21 11:37
文章分类

全部博文(59)

文章存档

2015年(1)

2014年(1)

2012年(1)

2011年(19)

2009年(1)

2008年(1)

2007年(11)

2006年(11)

2005年(13)

分类: Python/Ruby

2011-03-23 15:17:02

 

 

线程与锁

 

 

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

 

 

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才能进行锁定,但t2t3会在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才能进行锁定,但t2t3会同t1一起进入等锁获取状态。

阅读(2701) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册