进程同步-锁
互斥锁
模拟抢票程序：
from multiprocessing import Process,Lock # 导入锁模块
import json
import time
import random
import os
def search():
time.sleep(random.randint(1,3))
dic=json.load(open('db.txt','r',encoding='utf-8'))
print('%s 查看到余票数%s' %(os.getpid(),dic['count']))
def get():
dic=json.load(open('db.txt','r',encoding='utf-8'))
if dic['count'] > 0:
dic['count'] -= 1
time.sleep(random.randint(1,3))
json.dump(dic,open('db.txt','w',encoding='utf-8'))
print("%s 购票成功！" %os.getpid())
def task(mutex):
search()
mutex.acquire() # 对写操作加锁
get()
mutex.release() # 写完成后解锁
if __name__=='__main__':
mutex=Lock()
for i in range(10):
p=Process(target=task,args=(mutex,))
p.start()
在多个进程要对同一个文件进行修改时，要避免出现多个进程同时修改的情况，这种情况下我们需要对修改这一步操作加锁，使他们串行运行（只在修改处串行运行），修改完成后解锁，只有解锁后下一个进程才能修改。
将并发变成串行，牺牲了效率，但是保证了数据安全。
信号量
信号量指是多个线程可以同时执行，可以理解为大家排队上厕所，而信号量就是厕所里面的坑位，一时抢占不到坑位的线程就排队等待，直到坑位被空出：
from threading import Thread, Semaphore, current_thread
import time, random
sm = Semaphore(5) # 信号量,允许同时开几个线程，这里指5个
def task():
with sm:
print('%s is laing' % current_thread().getName())
time.sleep(random.randint(1, 3))
if __name__ == '__main__':
for i in range(20):
t = Thread(target=task)
t.start()
死锁与递归锁
死锁现象： 当进程/线程A 那到A锁后接着想要获取B锁，而此时B锁被进程/线程B拥有，B进程/线程想要获取A锁，这样A，B两个进程/线程相互等待的卡死的现象叫做死锁现象。
解决办法，使用递归锁：
from threading import Thread, RLock
import time
mutexA = mutexB = RLock()
class MyThread(Thread):
def run(self):
self.f1()
self.f2()
def f1(self):
mutexA.acquire()
print('%s 拿到了A锁' % self.name)
mutexB.acquire()
print('%s 拿到了B锁' % self.name)
mutexA.release()
mutexB.release()
def f2(self):
mutexB.acquire()
print('%s 拿到了B锁' % self.name)
time.sleep(0.1)
mutexA.acquire()
print('%s 拿到了A锁' % self.name)
mutexA.release()
mutexB.release()
if __name__ == '__main__':
for i in range(10):
t = MyThread()
t.start()
输出结果：
Thread-1 拿到了A锁
Thread-1 拿到了B锁
Thread-1 拿到了B锁
Thread-1 拿到了A锁
Thread-2 拿到了A锁
Thread-2 拿到了B锁
Thread-2 拿到了B锁
Thread-2 拿到了A锁
Thread-4 拿到了A锁
Thread-4 拿到了B锁
Thread-4 拿到了B锁
Thread-4 拿到了A锁
Thread-6 拿到了A锁
Thread-6 拿到了B锁
Thread-6 拿到了B锁
Thread-6 拿到了A锁
Thread-8 拿到了A锁
Thread-8 拿到了B锁
Thread-8 拿到了B锁
Thread-8 拿到了A锁
Thread-10 拿到了A锁
Thread-10 拿到了B锁
Thread-10 拿到了B锁
Thread-10 拿到了A锁
Thread-5 拿到了A锁
Thread-5 拿到了B锁
Thread-5 拿到了B锁
Thread-5 拿到了A锁
Thread-9 拿到了A锁
Thread-9 拿到了B锁
Thread-9 拿到了B锁
Thread-9 拿到了A锁
Thread-7 拿到了A锁
Thread-7 拿到了B锁
Thread-7 拿到了B锁
Thread-7 拿到了A锁
Thread-3 拿到了A锁
Thread-3 拿到了B锁
Thread-3 拿到了B锁
Thread-3 拿到了A锁
使用Rlock,当锁被加到线程后，会对锁进行一次计数，再次加锁计数会增加1次，只有当锁全部释放后计数归零，此时才能允许其他线程加锁。
Event 事件
当一个线程运行前必须有其他初始化的工作，等待其他线程初始化完成之后才能启动此进程开始工作，或者在有些场景下唤起某个正在等待的线程继续工作，在这种场景下就需要使用event事件进行处理。
初始情况下Event对象中的信号标志被设置为假，如果有线程等待一个Event对象，而这个Event对象的标志位假，难么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号设置为真，它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象，那么它将忽略这个事件，继续执行。
常用方法如下：
event.isSet(): 返回event的状态值
event.wait(): 如果event.isSet() == False 将阻塞线程
event.set(): 设置event的状态值为True,所有阻塞池的线程激活进入就绪状态，等待操作系统调度
event.clear(): 恢复event的状态值为False
示例代码：
from threading import Thread, Event, current_thread
import time
event = Event() # 初始状态下event回阻塞其他线程
def check():
print('checking MySQL ...')
time.sleep(5)
event.set() # 激活其他线程，修改event状态为True
print(event.is_set())
def conn():
count = 1
while not event.is_set(): # 判断当前的状态是否为阻塞状态，阻塞状态为False
if count > 3: # 设置尝试次数,超过3次抛出超时异常
raise TimeoutError('time out...')
print('%s trying to connect MySQL %s times...' % (current_thread().getName(), count))
event.wait(3)
count += 1
print('%s connect MySQL' % current_thread().getName())
if __name__ == '__main__':
t1 = Thread(target=check)
t2 = Thread(target=conn)
t3 = Thread(target=conn)
t1.start()
t2.start()
t3.start()
输出结果：
checking MySQL ...
Thread-2 trying to connect MySQL 1 times...
Thread-3 trying to connect MySQL 1 times...
Thread-3 trying to connect MySQL 2 times...
Thread-2 trying to connect MySQL 2 times...
TrueThread-3 connect MySQL
Thread-2 connect MySQL
定时器
在一段时间以后运行一个任务,一般可以用于验证码的场景。
from threading import Timer
def hello(name):
print('hello world! %s' % name)
t = Timer(3, hello, args=('come on!',)) # 3秒之后自动触发运行 hello
t.start()
