Python中threading模块 lock、Rlock的使用

巴掌

一、概述

在使用多线程的应用下，如何保证线程安全，以及线程之间的同步，或者访问共享变量等问题是十分棘手的问题，也是使用多线程下面临的问题，如果处理不好，会带来较严重的后果，使用python多线程中提供Lock 、Rlock 、Semaphore 、Event 、Condition 用来保证线程之间的同步，后者保证访问共享变量的互斥问题。

• Lock & RLock：互斥锁，用来保证多线程访问共享变量的问题
  
• Semaphore对象：Lock互斥锁的加强版，可以被多个线程同时拥有，而Lock只能被某一个线程同时拥有。
  
• Event对象：它是线程间通信的方式，相当于信号，一个线程可以给另外一个线程发送信号后让其执行操作。
  
• Condition对象：其可以在某些事件触发或者达到特定的条件后才处理数据
  

1、Lock(互斥锁)

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

Lock（指令锁）是可用的最低级的同步指令。Lock处于锁定状态时，不被特定的线程拥有。Lock包含两种状态——锁定和非锁定，以及两个基本的方法。
可以认为Lock有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。
构造方法：mylock = Threading.Lock( )
实例方法：

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

实例一（未使用锁）：

1. import threading
2. import time
4. num = 0
6. def show(arg):
7.     global num
8.     time.sleep(1)
9.     num +=1
10.     print('bb :{}'.format(num))
12. for i in range(5):
13.     t = threading.Thread(target=show, args=(i,))  # 注意传入参数后一定要有【，】逗号
14.     t.start()
16. print('main thread stop')
18. --------------------------------------------------------------------------
19. main thread stop
20. bb :1
21. bb :2
22. bb :3bb :4
23. bb :5

复制代码

实例二（使用锁）

1. import threading
2. import time
4. num = 0
6. lock = threading.RLock()
9. # 调用acquire([timeout])时，线程将一直阻塞，
10. # 直到获得锁定或者直到timeout秒后（timeout参数可选）。
11. # 返回是否获得锁。
12. def Func():
13.     lock.acquire()
14.     global num
15.     num += 1
16.     time.sleep(1)
17.     print(num)
18.     lock.release()
21. for i in range(10):
22.     t = threading.Thread(target=Func)
23.     t.start()
24. ------------------------------------------------------------------
25. 1
26. 2
27. 3
28. 4
29. 5
30. 6
31. 7
32. 8
33. 9
34. 10
35. #可以看出，全局变量在在每次被调用时都要获得锁，才能操作，因此保证了共享数据的安全性

复制代码

对于Lock对象而言，如果一个线程连续两次release，使得线程死锁。所以Lock不常用，一般采用Rlock进行线程锁的设定。

1. import threading
2. import time
4. class MyThread(threading.Thread):
5.     def run(self):
6.         global num
7.         time.sleep(1)
9.         if lock.acquire(1):  
10.             num = num+1
11.             msg = self.name+' set num to '+str(num)
12.             print(msg)
13.             lock.acquire()
14.             lock.release()
15.             lock.release()
16. num = 0
17. lock = threading.Lock()
18. def test():
19.     for i in range(5):
20.         t = MyThread()
21.         t.start()
22. if __name__ == '__main__':
23.     test()
24. ------------------------------------------------------
25. Thread-12 set num to 1

复制代码

2、RLock(可重入锁)

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

• 构造方法：mylock = Threading.RLock()
  
• 实例方法：acquire([timeout])/release(): 跟Lock差不多。
  

实例解决死锁，调用相同次数的acquire和release，保证成对出现

1. import threading
2. rLock = threading.RLock()  #RLock对象
3. rLock.acquire()
4. rLock.acquire() #在同一线程内，程序不会堵塞。
5. rLock.release()
6. rLock.release()
8. print(rLock.acquire())

复制代码

详细实例：

1. import threading
2. mylock = threading.RLock()
3. num = 0
4. class WorkThread(threading.Thread):
5.     def __init__(self, name):
6.         threading.Thread.__init__(self)
7.         self.t_name = name
8.     def run(self):
9.         global num
10.         while True:
11.             mylock.acquire()
12.             print('\n%s locked, number: %d' % (self.t_name, num))
13.             if num >= 2:
14.                 mylock.release()
15.                 print('\n%s released, number: %d' % (self.t_name, num))
16.                 break
17.             num += 1
18.             print('\n%s released, number: %d' % (self.t_name, num))
19.             mylock.release()
20. def test(): #Python小白学习交流群：711312441
21.     thread1 = WorkThread('A-Worker')
22.     thread2 = WorkThread('B-Worker')
23.     thread1.start()
24.     thread2.start()
25. if __name__ == '__main__':
26.     test()
27. --------------------------------------------------
28. A-Worker locked, number: 0
30. A-Worker released, number: 1
32. A-Worker locked, number: 1
34. A-Worker released, number: 2
36. A-Worker locked, number: 2
38. A-Worker released, number: 2
40. B-Worker locked, number: 2
42. B-Worker released, number: 2

复制代码

来源:https://www.cnblogs.com/xxpythonxx/p/17629487.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！