考虑这种情况：如果一个线程遇到锁嵌套的情况该怎么办，这个嵌套是指当我一个线程在获取临界资源时，又需要再次获取。

        根据这种情况，代码如下：

Python代码

  1. '''''
  2. Created on 2012-9-8
  4. @author: walfred
  5. @module: thread.ThreadTest6
  6. '''
  8. import threading 
  9. import time 
  11. counter = 0
  12. mutex = threading.Lock() 
  14. class MyThread(threading.Thread): 
  15. def __init__(self): 
  16.         threading.Thread.__init__(self) 
  18. def run(self): 
  19. global counter, mutex 
  20.         time.sleep(1); 
  21. if mutex.acquire(): 
  22.             counter += 1
  23. print "I am %s, set counter:%s" % (self.name, counter) 
  24. if mutex.acquire(): 
  25.                 counter += 1
  26. print "I am %s, set counter:%s" % (self.name, counter) 
  27.                 mutex.release() 
  28.             mutex.release() 
  30. if __name__ == "__main__": 
  31. for i in range(0, 200): 
  32.         my_thread = MyThread() 
  33.         my_thread.start()        

        这种情况的代码运行情况如下：

I am Thread-1, set counter:1

        之后就直接挂起了，这种情况形成了最简单的死锁。

        那有没有一种情况可以在某一个线程使用互斥锁访问某一个竞争资源时，可以再次获取呢？在Python中为了支持在同一线程中多次请求同一资源，python提供了“可重入锁”：threading.RLock。这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：

        代码只需将上述的：

Python代码

  1. mutex = threading.Lock() 

        替换成：

Python代码

  1. mutex = threading.RLock() 

        即可。