通过锁可以保证线程与进程的安全

---

死锁与递归锁

死锁：当一个线程或者进程抢到了一把锁，且执行下一步的操作时，还需要一把锁，但是这把锁被另外一个进程或者线程拿到了，那么就会出现死锁现象。

死锁示例：

from threading import Thread, Lock
import time


mutexA = Lock()
mutexB = Lock()
# 类只要加括号多次 产生的肯定是不同的对象
# 如果你想要实现多次加括号等到的是相同的对象 单例模式


class MyThead(Thread):
    def run(self):
        self.func1()
        self.func2()

    def func1(self):
        mutexA.acquire()
        print('%s 抢到A锁'% self.name)  
        mutexB.acquire()
        print('%s 抢到B锁'% self.name)
        mutexB.release()
        mutexA.release()
        
    def func2(self):
        mutexB.acquire()
        print('%s 抢到B锁'% self.name)
        time.sleep(2)
        mutexA.acquire()
        print('%s 抢到A锁'% self.name)  
        mutexA.release()
        mutexB.release()


if __name__ == '__main__':
    for i in range(10):
        t = MyThead()
        t.start()

递归锁可以让一个锁可以被多次加锁，同时解锁与需要相应的次数。

from threading import Thread, RLock
A = Lock()

# 加锁（可加多次）
A.acquire()

# 解锁（可多次）
A.release()

信号量

通过信号量，可以实现限制同时有几个线程同时执行的效果

from threading import Thread, Semaphore
import time
import random


se = Semaphore(5)  # 括号内写数字 写几就表示开设几个坑位


def task():
    se.acquire()
    print('启动' )
    time.sleep(random.randint(1, 5))
    se.release()


if __name__ == '__main__':
    for i in range(20):
        t = Thread(target=task,)
        t.start()

Event

当一个进程或者线程的某个动作执行完成，其他进程或者线程才能执行后续的任务

from threading import Thread, Event
import time

# 生成事件
event = Event()  


def light():
    print('红灯亮着的')
    time.sleep(3)
    print('绿灯亮了')
    # 设置事件
    event.set()


def car(name):
    print('%s 车正在灯红灯'%name)
    # 等待事件的通知，后续的代码需要 light中的envent.set()后才能执行
    event.wait()  
    print('%s 车加油门飙车走了'%name)


if __name__ == '__main__':
    t = Thread(target=light)
    t.start()

    for i in range(20):
        t = Thread(target=car, args=('%s'%i, ))
        t.start()