厮守给你的承诺 发表于 2024-2-28 21:09:19

python中5种线程锁

线程安全

线程安全是多线程或多进程编程中的一个概念,在拥有共享数据的多条线程并行执行的程序中,线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行,不会出现数据污染等意外情况。
线程安全的问题最主要还是由线程切换导致的,比如一个房间(进程)中有10颗糖(资源),除此之外还有3个小人(1个主线程、2个子线程),当小人A吃了3颗糖后被系统强制进行休息时他认为还剩下7颗糖,而当小人B工作后又吃掉了3颗糖,那么当小人A重新上岗时会认为糖还剩下7颗,但是实际上只有4颗了。
上述例子中线程A和线程B的数据不同步,这就是线程安全问题,它可能导致非常严重的意外情况发生,我们按下面这个示例来进行说明。
下面有一个数值num初始值为0,我们开启2条线程:

[*]线程1对num进行一千万次+1的操作
[*]线程2对num进行一千万次-1的操作
结果可能会令人咋舌,num最后并不是我们所想象的结果0:
import threading

num = 0


def add():
    global num
    for i in range(10_000_000):
      num += 1


def sub():
    global num
    for i in range(10_000_000):
      num -= 1


if __name__ == "__main__":
    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

# 结果三次采集
# num result : 669214
# num result : -1849179
# num result : -525674上面这就是一个非常好的案例,想要解决这个问题就必须通过锁来保障线程切换的时机。
需要我们值得留意的是,在Python基本数据类型中list、tuple、dict本身就是属于线程安全的,
所以如果有多个线程对这3种容器做操作时,我们不必考虑线程安全问题。
锁的作用

锁是Python提供给我们能够自行操控线程切换的一种手段,使用锁可以让线程的切换变的有序。
一旦线程的切换变的有序后,各个线程之间对数据的访问、修改就变的可控,所以若要保证线程安全,就必须使用锁。
threading模块中提供了5种最常见的锁,下面是按照功能进行划分:

[*]同步锁:lock(一次只能放行一个)
[*]递归锁:rlock(一次只能放行一个)
[*]条件锁:condition(一次可以放行任意个)
[*]事件锁:event(一次全部放行)
[*]信号量锁:semaphore(一次可以放行特定个)
1、Lock() 同步锁

基本介绍
Lock锁的称呼有很多,如:

[*]同步锁
[*]互斥锁
它们是什么意思呢?如下所示:

[*]互斥指的是某一资源同一时刻仅能有一个访问者对其进行访问,具有唯一性和排他性,但是互斥无法限制访问者对资源的访问顺序,即访问是无序的
[*]同步是指在互斥的基础上(大多数情况),通过其他机制实现访问者对资源的有序访问
[*]同步其实已经实现了互斥,是互斥的一种更为复杂的实现,因为它在互斥的基础上实现了有序访问的特点
下面是threading模块与同步锁提供的相关方法:
使用方式
同步锁一次只能放行一个线程,一个被加锁的线程在运行时不会将执行权交出去,只有当该线程被解锁时才会将执行权通过系统调度交由其他线程。
如下所示,使用同步锁解决最上面的问题:
import threading

num = 0

def add():
    lock.acquire()
    global num
    for i in range(10_000_000):
      num += 1
    lock.release()


def sub():
    lock.acquire()
    global num
    for i in range(10_000_000):
      num -= 1
    lock.release()

if __name__ == "__main__":
    lock = threading.Lock()

    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

# 结果三次采集
# num result : 0
# num result : 0
# num result : 0这样这个代码就完全变成了串行的状态,对于这种计算密集型I/O业务来说,还不如直接使用串行化单线程执行来得快,所以这个例子仅作为一个示例,不能概述锁真正的用途。
死锁现象
对于同步锁来说,一次acquire()必须对应一次release(),不能出现连续重复使用多次acquire()后再重复使用多次release()的操作,这样会引起死锁造成程序的阻塞,完全不动了,如下所示:
import threading

num = 0


def add():
    lock.acquire()# 上锁
    lock.acquire()# 死锁
    # 不执行
    global num
    for i in range(10_000_000):
      num += 1
    lock.release()
    lock.release()


def sub():
    lock.acquire()# 上锁
    lock.acquire()# 死锁
    # 不执行
    global num
    for i in range(10_000_000):
      num -= 1
    lock.release()
    lock.release()


if __name__ == "__main__":
    lock = threading.Lock()

    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)with语句
由于threading.Lock()对象中实现了enter__()与__exit()方法,故我们可以使用with语句进行上下文管理形式的加锁解锁操作:
import threading

num = 0


def add():
    with lock:
      # 自动加锁
      global num
      for i in range(10_000_000):
            num += 1
      # 自动解锁


def sub():
    with lock:
      # 自动加锁
      global num
      for i in range(10_000_000):
            num -= 1
      # 自动解锁


if __name__ == "__main__":
    lock = threading.Lock()

    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

# 结果三次采集
# num result : 0
# num result : 0
# num result : 02、RLock() 递归锁

基本介绍
递归锁是同步锁的一个升级版本,在同步锁的基础上可以做到连续重复使用多次acquire()后再重复使用多次release()的操作,但是一定要注意加锁次数和解锁次数必须一致,否则也将引发死锁现象。
下面是threading模块与递归锁提供的相关方法:

使用方式
以下是递归锁的简单使用,下面这段操作如果使用同步锁则会发生死锁现象,但是递归锁不会:
import threading

num = 0


def add():
    lock.acquire()
    lock.acquire()
    global num
    for i in range(10_000_000):
      num += 1
    lock.release()
    lock.release()


def sub():
    lock.acquire()
    lock.acquire()
    global num
    for i in range(10_000_000):
      num -= 1
    lock.release()
    lock.release()


if __name__ == "__main__":
    lock = threading.RLock()

    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

# 结果三次采集
# num result : 0
# num result : 0
# num result : 0with语句
由于threading.RLock()对象中实现了enter__()与__exit()方法,故我们可以使用with语句进行上下文管理形式的加锁解锁操作:
import threading

num = 0


def add():
    with lock:
      # 自动加锁
      global num
      for i in range(10_000_000):
            num += 1
      # 自动解锁


def sub():
    with lock:
      # 自动加锁
      global num
      for i in range(10_000_000):
            num -= 1
      # 自动解锁


if __name__ == "__main__":
    lock = threading.RLock()

    subThread01 = threading.Thread(target=add)
    subThread02 = threading.Thread(target=sub)

    subThread01.start()
    subThread02.start()

    subThread01.join()
    subThread02.join()

    print("num result : %s" % num)

# 结果三次采集
# num result : 0
# num result : 0
# num result : 03、Condition() 条件锁

基本介绍
条件锁是在递归锁的基础上增加了能够暂停线程运行的功能。并且我们可以使用wait()与notify()来控制线程执行的个数。
注意:条件锁可以自由设定一次放行几个线程。
下面是threading模块与条件锁提供的相关方法:

使用方式
下面这个案例会启动10个子线程,并且会立即将10个子线程设置为等待状态。
然后我们可以发送一个或者多个通知,来恢复被等待的子线程继续运行:
import threading

currentRunThreadNumber = 0
maxSubThreadNumber = 10


def task():
    global currentRunThreadNumber
    thName = threading.currentThread().name

    condLock.acquire()# 上锁
    print("start and wait run thread : %s" % thName)

    condLock.wait()# 暂停线程运行、等待唤醒
    currentRunThreadNumber += 1
    print("carry on run thread : %s" % thName)

    condLock.release()# 解锁


if __name__ == "__main__":
    condLock = threading.Condition()

    for i in range(maxSubThreadNumber):
      subThreadIns = threading.Thread(target=task)
      subThreadIns.start()

    while currentRunThreadNumber < maxSubThreadNumber:
      notifyNumber = int(
            input("Please enter the number of threads that need to be notified to run:"))

      condLock.acquire()
      condLock.notify(notifyNumber)# 放行
      condLock.release()

    print("main thread run end")

# 先启动10个子线程,然后这些子线程会全部变为等待状态
# start and wait run thread : Thread-1
# start and wait run thread : Thread-2
# start and wait run thread : Thread-3
# start and wait run thread : Thread-4
# start and wait run thread : Thread-5
# start and wait run thread : Thread-6
# start and wait run thread : Thread-7
# start and wait run thread : Thread-8
# start and wait run thread : Thread-9
# start and wait run thread : Thread-10

# 批量发送通知,放行特定数量的子线程继续运行
# Please enter the number of threads that need to be notified to run:5# 放行5个
# carry on run thread : Thread-4
# carry on run thread : Thread-3
# carry on run thread : Thread-1
# carry on run thread : Thread-2
# carry on run thread : Thread-5
#学习中遇到问题没人解答?小编创建了一个Python学习交流群:725638078

# Please enter the number of threads that need to be notified to run:5# 放行5个
# carry on run thread : Thread-8
# carry on run thread : Thread-10
# carry on run thread : Thread-6
# carry on run thread : Thread-9
# carry on run thread : Thread-7

# Please enter the number of threads that need to be notified to run:1
# main thread run endwith语句
由于threading.Condition()对象中实现了enter__()与__exit()方法,故我们可以使用with语句进行上下文管理形式的加锁解锁操作:
import threading

currentRunThreadNumber = 0
maxSubThreadNumber = 10


def task():
    global currentRunThreadNumber
    thName = threading.currentThread().name

    with condLock:
      print("start and wait run thread : %s" % thName)
      condLock.wait()# 暂停线程运行、等待唤醒
      currentRunThreadNumber += 1
      print("carry on run thread : %s" % thName)


if __name__ == "__main__":
    condLock = threading.Condition()

    for i in range(maxSubThreadNumber):
      subThreadIns = threading.Thread(target=task)
      subThreadIns.start()

    while currentRunThreadNumber < maxSubThreadNumber:
      notifyNumber = int(
            input("Please enter the number of threads that need to be notified to run:"))

      with condLock:
            condLock.notify(notifyNumber)# 放行

    print("main thread run end")4、Event() 事件锁

基本介绍
事件锁是基于条件锁来做的,它与条件锁的区别在于一次只能放行全部,不能放行任意个数量的子线程继续运行。
我们可以将事件锁看为红绿灯,当红灯时所有子线程都暂停运行,并进入“等待”状态,当绿灯时所有子线程都恢复“运行”。
下面是threading模块与事件锁提供的相关方法:

使用方式
事件锁不能利用with语句来进行使用,只能按照常规方式。
如下所示,我们来模拟线程和红绿灯的操作,红灯停,绿灯行:
# 生成一个事件锁对象
eve = threading.Event()


# 将事件锁设置为红灯状态
eve.clear()

# 判断事件锁的状态
eve.is_set()


# 将当前线程设置’等待‘状态
eve.wait()


# 将事件锁设置为绿灯状态
eve.set()


import time
import threading


def light(eve):
    print(f'当前时间:{time.ctime()}, 红灯还有 5s 结束!')
    time.sleep(5)
    print(f'当前时间:{time.ctime()}, 绿灯亮!')
    eve.set()   # 设置事件锁标志为 True

def car(eve, name):
    print(f'当前时间:{time.ctime()}, 车 {name} 正在等红灯')
    eve.wait()    # 将当前线程设置为等待状态,等待事件锁标志为 True 再执行
    print(f'当前时间:{time.ctime()}, 车 {name} 开始通行')



if __name__ == '__main__':
    eve = threading.Event()   # 事件锁默认标志为 False
    t1 = threading.Thread(target=light, args=(eve,))
    t1.start()

    for each in 'ABCDE':
      t2 = threading.Thread(target=car, args=(eve, each))
      t2.start()


#学习中遇到问题没人解答?小编创建了一个Python学习交流群:725638078
# 执行看一下打印结果
当前时间:Fri Jul 29 11:32:58 2022, 红灯还有 5s 结束!
当前时间:Fri Jul 29 11:32:58 2022, 车 A 正在等红灯
当前时间:Fri Jul 29 11:32:58 2022, 车 B 正在等红灯
当前时间:Fri Jul 29 11:32:58 2022, 车 C 正在等红灯
当前时间:Fri Jul 29 11:32:58 2022, 车 D 正在等红灯
当前时间:Fri Jul 29 11:32:58 2022, 车 E 正在等红灯
当前时间:Fri Jul 29 11:33:03 2022, 绿灯亮!
当前时间:Fri Jul 29 11:33:03 2022, 车 C 开始通行
当前时间:Fri Jul 29 11:33:03 2022, 车 B 开始通行
当前时间:Fri Jul 29 11:33:03 2022, 车 E 开始通行
当前时间:Fri Jul 29 11:33:03 2022, 车 A 开始通行
当前时间:Fri Jul 29 11:33:03 2022, 车 D 开始通行5、Semaphore() 信号量锁

基本介绍
信号量锁也是根据条件锁来做的,它与条件锁和事件锁的区别如下:

[*]条件锁:一次可以放行任意个处于“等待”状态的线程
[*]事件锁:一次可以放行全部的处于“等待”状态的线程
[*]信号量锁:通过规定,成批的放行特定个处于“上锁”状态的线程
下面是threading模块与信号量锁提供的相关方法:

使用方式
以下是使用示例,你可以将它当做一段限宽的路段,每次只能放行相同数量的线程:
import threading
import time

maxSubThreadNumber = 6


def task():
    thName = threading.currentThread().name
    semaLock.acquire()
    print("run sub thread %s" % thName)
    time.sleep(3)
    semaLock.release()


if __name__ == "__main__":
    # 每次只能放行2个
    semaLock = threading.Semaphore(2)

    for i in range(maxSubThreadNumber):
      subThreadIns = threading.Thread(target=task)
      subThreadIns.start()


# run sub thread Thread-1
# run sub thread Thread-2

# run sub thread Thread-3
# run sub thread Thread-4

# run sub thread Thread-6
# run sub thread Thread-5with语句
由于threading.Semaphore()对象中实现了enter__()与__exit()方法,故我们可以使用with语句进行上下文管理形式的加锁解锁操作:
import threading
import time

maxSubThreadNumber = 6


def task():
    thName = threading.currentThread().name
    with semaLock:
      print("run sub thread %s" % thName)
      time.sleep(3)


if __name__ == "__main__":

    semaLock = threading.Semaphore(2)

    for i in range(maxSubThreadNumber):
      subThreadIns = threading.Thread(target=task)
      subThreadIns.start()锁关系浅析

上面5种锁可以说都是基于同步锁来做的,这些你都可以从源码中找到答案。
首先来看RLock递归锁,递归锁的实现非常简单,它的内部会维护着一个计数器,当计数器不为0的时候该线程不能被I/O操作和时间轮询机制切换。但是当计数器为0的时候便不会如此了:
def __init__(self):
    self._block = _allocate_lock()
    self._owner = None
    self._count = 0# 计数器而Condition条件锁的内部其实是有两把锁的,一把底层锁(同步锁)一把高级锁(递归锁)。
低层锁的解锁方式有两种,使用wait()方法会暂时解开底层锁同时加上一把高级锁,只有当接收到别的线程里的notfiy()后才会解开高级锁和重新上锁低层锁,也就是说条件锁底层是根据同步锁和递归锁的不断切换来进行实现的:
def __init__(self, lock=None):   
    if lock is None:      
      lock = RLock()# 可以看到条件锁的内部是基于递归锁,而递归锁又是基于同步锁来做的   
      self._lock = lock   
      self.acquire = lock.acquire   
      self.release = lock.release   
      try:      
            self._release_save = lock._release_save   
      except AttributeError:      
            pass   
      try:      

            self._acquire_restore = lock._acquire_restore   
      except AttributeError:      
            pass   
      try:      
            self._is_owned = lock._is_owned   
      except AttributeError:      
      pass   
      self._waiters = _deque()基本练习题

条件锁的应用

需求:一个空列表,两个线程轮番往里面加值(一个加偶数,一个加奇数),最终让该列表中的值为 1 - 100 ,且是有序排列的。
import threading

lst = []


def even():
    """加偶数"""
    with condLock:
      for i in range(2, 101, 2):
            # 判断当前列表的长度处于2是否能处尽
            # 如果能处尽则代表需要添加奇数
            # 否则就添加偶数
            if len(lst) % 2 != 0:
                # 添偶数
                lst.append(i)      # 先添加值
                condLock.notify()# 告诉另一个线程,你可以加奇数了,但是这里不会立即交出执行权
                condLock.wait()    # 交出执行权,并等待另一个线程通知加偶数
            else:
                # 添奇数
                condLock.wait()# 交出执行权,等待另一个线程通知加偶数
                lst.append(i)
                condLock.notify()
      condLock.notify()


def odd():
    """加奇数"""
    with condLock:
      for i in range(1, 101, 2):
            if len(lst) % 2 == 0:
                lst.append(i)
                condLock.notify()
                condLock.wait()
      condLock.notify()

#学习中遇到问题没人解答?小编创建了一个Python学习交流群:725638078
if __name__ == "__main__":
    condLock = threading.Condition()

    addEvenTask = threading.Thread(target=even)
    addOddTask = threading.Thread(target=odd)

    addEvenTask.start()
    addOddTask.start()

    addEvenTask.join()
    addOddTask.join()

    print(lst)事件锁的应用

有2个任务线程来扮演李白和杜甫,如何让他们一人一句进行对答?文本如下:
杜甫:老李啊,来喝酒!
李白:老杜啊,不喝了我喝不下了!
杜甫:老李啊,再来一壶?
杜甫:…老李?
李白:呼呼呼…睡着了..
代码如下:
import threading


def libai():
    event.wait()
    print("李白:老杜啊,不喝了我喝不下了!")
    event.set()
    event.clear()
    event.wait()
    print("李白:呼呼呼...睡着了..")

def dufu():
    print("杜甫:老李啊,来喝酒!")
    event.set()
    event.clear()
    event.wait()
    print("杜甫:老李啊,再来一壶?")
    print("杜甫:...老李?")
    event.set()


if __name__ == '__main__':

    event = threading.Event()

    t1 = threading.Thread(target=libai)
    t2 = threading.Thread(target=dufu)

    t1.start()
    t2.start()
    t1.join()
    t2.join()
来源:https://www.cnblogs.com/djdjdj123/p/18040870
免责声明:由于采集信息均来自互联网,如果侵犯了您的权益,请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容,谢谢合作!
页: [1]
查看完整版本: python中5种线程锁