python中的锁

为什么要有锁？
在我们编写的代码中难免会用到共享数据/资源，但是当多线程或者进程在对共享资源/数据进行操作的时候，如修改共享资源，由于并发的特性，当一个线程在修改一半的时候，可能cpu会调度另一个线程再次进行修改，这样共享资源/数据 就可能不能保持同步，程序会读脏数据，为了避免这种情况，在每个线程在对共享数据或资源修改之前应该先上锁，每个时刻让一个线程或进程拿到数据或资源进行修改，或者称为线程或进程进入自己的临界区，处理完数据或资源后，在对锁进行释放即可，这样就能保证共享资源或数据的正确性

1. Lock锁（一次只能锁一个线程，释放一个锁，锁不能嵌套，或者说不能一次上多把锁）

import threading
import time
lock = threading.Lock()

def func(args):
    t = threading.current_thread()
    lock.acquire()#进行上锁
    print(t.getName())
    print(args)
    time.sleep(1)
    lock.relase() #释放锁
for i in range(10):
    t = threading.Thread(target=func,args=(i,))
    t.setName(f"线程{i}")
    t.start()

2. Rlock 锁（也是一次只能锁一个线程，但是允许上多把锁，允许锁嵌套）

import threading
import time

lock = threading.RLock()
def func(args):
    t = threading.current_thread()
    lock.acquire() #上锁
    lock.acquire()
    print(t.getName())
    print(args)
    time.sleep(1)
    lock.release()
    lock.release() #释放锁

for i in range(10):
    t = threading.Thread(target=func,args=(i,))
    t.setName(f"线程{i}")
    t.start()

3. 信号量/同步锁 semaphore (一次锁的线程数量，可以进行控制)

import threading
import time

lock = threading.BoundedSemaphore(3) #一次锁三个线程

def func(args):
    t = threading.current_thread()
    lock.acquire() #上锁
    print(t.getName(),end="\n")
    print(args,end="\n")
    time.sleep(1)
    lock.release() #释放锁

for i in range(10):
    t = threading.Thread(target=func,args=(i,))
    t.setName(f"线程{i}")
    t.start()

4. Condition锁 （有条件的上锁，一次唤醒的线程可以自己控制）

import threading
import time

lock = threading.Condition()

def condition_func():
    #这里是设置的条件，只有当这个条件满足时，线程才往下走
    print("hello world")
    return True
def func(args):
    t = threading.current_thread()
    lock.wait_for(condition_func) #只有当这个条件满足之后，线程才能往下继续运行
    print(t.getName(),end="\n")
    print(args,end="\n")
    time.sleep(1)

for i in range(10):
    t = threading.Thread(target=func,args=(i,))
    t.setName(f"线程{i}")
    t.start()


def func(args):
    t = threading.current_thread()
    print("线程来了")
    lock.acquire()
    lock.wait()
    print(t.getName())
    print(args)
    time.sleep(1)
    lock.release()

if __name__ == "__main__":
    for i in range(10):
        t = threading.Thread(target=func, args=(i,))
        t.setName(f"线程{i}")
        t.start()
    while True:
        num = int(input("请输入要释放的线程的数量"))
        lock.acquire()
        lock.notify(num) #自己控制一次唤醒几个线程，也就是一次释放几个锁
        lock.release()

5. Event锁 （一次释放所有锁），在Event锁中，当我们执行了lock.set()语句之后，那么我们上锁机制就已经失效了，下次在创建线程的时候，锁就已经不存在了，当我们需要在次让锁生效，在创建新的线程时候，需要执行lock.clear()语句，这样我们原先上的锁就会再次生效, lock.set()和lock.clear()语句内部修改的时一个self._flag 变量, lock.set()将其设置为True, lock.clear()将其修改为False，来设置锁是否生效就是判断这个_flag的bool值是否为真

import threading
import time

lock = threading.Event()

def func(args):
    t = threading.current_thread()
    print("线程来了")
    lock.wait()  #所有线程都进入不了临界区
    print(t.getName())
    print(args)
    time.sleep(1)

if __name__ == "__main__":
    for i in range(10):
        t = threading.Thread(target=func,args=(i,))
        t.setName(f"线程{i}")
        t.start()
    while True:
        check = input("是否释放所有线程(Y/N):")
        if check == "Y":
            lock.set()