上锁和解锁是一对,只上锁不解锁会发生死锁现象(代码阻塞,不往下执行)
互斥锁:互斥锁是进程之间的相互排斥,谁先抢到这个锁资源就先使用,后抢到后使用
我们先来看看只上锁不解锁情况:
from multiprocessing import Process,Lock
count=5
def func1(lock):
#上锁
lock.acquire()
global count
count -= 1
print("我是func1,count:{}".format(count))
# 解锁
# lock.release()
def func2(lock):
lock.acquire()
global count
count -= 1
print("我是func2,count:{}".format(count))
# 解锁
lock.release()
if __name__=="__main__":
# 创建一把锁
lock = Lock()
p1=Process(target=func1,args=(lock,))
p2=Process(target=func2,args=(lock,))
p1.start()
p2.start()
p1.join()
p2.join()
print("执行程序 ...")
如图,由于func1一直没有解锁,所以一直卡在func1进程的执行处
接下来我们解锁:
from multiprocessing import Process,Lock
count=5
def func1(lock):
#上锁
lock.acquire()
global count
count -= 1
print("我是func1,count:{}".format(count))
# 解锁
lock.release()
def func2(lock):
lock.acquire()
global count
count -= 1
print("我是func2,count:{}".format(count))
# 解锁
lock.release()
if __name__=="__main__":
# 创建一把锁
lock = Lock()
p1=Process(target=func1,args=(lock,))
p2=Process(target=func2,args=(lock,))
p1.start()
p2.start()
p1.join()
p2.join()
print("执行程序 ...")
如图,解锁后三个进程执行完毕。
模拟一张票ticket,同时多个人在抢
ticket文件:{“count”:1}
from multiprocessing import Process,Lock
import json,time
def rw_info(sign,dic=None):
if sign == "r":
with open("ticket",mode="r",encoding="utf-8") as fp:
dic=json.load(fp)
return dic
elif sign == "w":
with open("ticket",mode="w",encoding="utf-8") as fp:
json.dump(dic,fp)
def get_ticket(person):
dic=rw_info("r")
time.sleep(0.5)
if dic["count"] > 0:
dic["count"] -= 1
print("{}抢到了票,票剩余{}".format(person, dic["count"]))
rw_info("w",dic)
else:
print("{}先生,票已被抢完,剩余{}张".format(person,dic["count"]))
def run(person,lock):
dic=rw_info("r")
print("{}先生 票剩余{}张".format(person,dic["count"]))
lock.acquire()
get_ticket(person)
lock.release()
if __name__ == "__main__":
lst = ["张三","李四","王五","赵六"]
lock=Lock()
for i in lst:
p=Process(target=run,args=(i,lock))
p.start()
如图,因为锁的存在,将每个人的抢票的动作锁死,多进程从异步变成了同步,故不会发生多个人抢到票的情况
总结:
创建进程时,仍然是异步并发,在执行到上所操作时,多个进程之间变成了同步程序,先来的先上锁,先执行,后来的进程后上锁,后执行
Semaphore本质就是上锁,只不过可以控制上所数量
from multiprocessing import Process,Semaphore
sem=Semaphore(4)
sem.acquire()
sem.acquire()
sem.acquire()
sem.acquire()
print("程序执行完毕")
并未出现死锁现象,如果添加第五把锁:
from multiprocessing import Process,Semaphore
sem=Semaphore(4)
sem.acquire()
sem.acquire()
sem.acquire()
sem.acquire()
sem.acquire()
print("程序执行完毕")
出现死锁!
案例:
模拟三个唱吧,多人排队唱歌
from multiprocessing import Process,Semaphore
import time
def func(person,sem):
time.sleep(0.5)
sem.acquire()
print("%s正在唱歌" %(person))
time.sleep(2)
print("%s唱完了,有请下一位" %(person))
sem.release()
if __name__=="__main__":
sem=Semaphore(3)
lst=["Lsir","Wsir","Msir","Zsir","Ksir","Jsir","Rsir","Psir","Ssir"]
for person in lst:
p=Process(target=func,args=(person,sem))
p.start()
阻塞事件:
控制这个属性的值:
set()方法 将这个属性的值改成True
clear()方法 将这个属性的值改为False
is_set()方法 判断当前属性是否为True
from multiprocessing import Process,Event
import time
e=Event()
print(e.is_set())
e.wait()
print("程序执行")
from multiprocessing import Process,Event
import time
e=Event()
e.set()
print(e.is_set())
e.wait()
print("程序执行")
from multiprocessing import Process,Event
import time
e=Event()
print("3秒后程序执行")
starttime=time.time()
e.wait(3)
endtime=time.time()
print("计时:{:.2f}".format(endtime-starttime))
print("程序执行")
from multiprocessing import Process,Event
import time,random
def traffic_light(e):
while True:
if e.is_set():
print("绿灯亮了")
time.sleep(3)
e.clear()
else:
print("红灯亮了")
time.sleep(3)
e.set()
def car(e,i):
if not e.is_set():
print("car{}在等待".format(i))
e.wait()
time.sleep(0.1)
print("car{}通行了".format(i))
if __name__=="__main__":
e = Event()
p1=Process(target=traffic_light,args=(e,))
队列特点:先进先出,后进后出
from multiprocessing import Process,Queue
q=Queue()
q.put(100)
q.put(101)
q.put(102)
res1=q.get()
print(res1)
res2=q.get()
print(res2)
res3=q.get()
print(res3)
队列可设置长度,超出长度将发生阻塞
from multiprocessing import Process,Queue
q=Queue(4)
q.put(100)
q.put(101)
q.put(102)
q.put(103)
q.put(104)
q.put(105)
res1=q.get()
print(res1)
res2=q.get()
print(res2)
res3=q.get()
print(res3)
from multiprocessing import Process,Queue
def func(q1):
res=q1.get()
print(res)
q1.put("你好啊")
if __name__=="__main__":
q1=Queue()
p=Process(target=func,args=(q1,))
q1.put("你好")
p.start()
p.join()
res=q1.get()
print(res)
以爬虫为例:
1号进程负责爬取页面中所有想要的数据
2号进程负责把内容取出来,按照规则进行匹配,扣取关键字
1号进程可以理解为生产者,2号进程可以理解为消费者
理想的生产者和消费者模型中,彼此的速度相对均匀
从程序上讲:生产者负责存储数据(put),消费者负责获取数据(get)
以生产厂商和消费者为例:
from multiprocessing import Process,Queue
import time
def consumer(q,name):
count=1
while True:
res=q.get()
if res is None:
break
time.sleep(0.1)
print("{}消费了第{}个{}".format(name,count,res))
count += 1
def producter(q,name,item):
for i in range(6):
time.sleep(0.1)
print("{}生产了{}个{}".format(name,i+1,item))
q.put(item)
if __name__=="__main__":
q=Queue()
p1=Process(target=consumer,args=(q,"Lsir"))
p2=Process(target=producter,args=(q,"Wsir","挂件"))
p1.start()
p2.start()
p2.join()
q.put(None)
扩展:JoinableQueue:
put 存储
get 获取
task_done
join
task_done 和 join 配合使用的
队列中 1 2 3 4 5
put 一次 内部的队列计数器加1
get 一次 通过task_done让队列计数器减1
join函数,会根据队列计数器来判断是阻塞还是放行
改写上例:
from multiprocessing import Process,JoinableQueue
import time
def consumer(q,name):
count=1
while True:
res=q.get()
time.sleep(0.1)
print("{}消费了第{}个{}".format(name,count,res))
count += 1
q.task_done()
def producter(q,name,item):
for i in range(6):
time.sleep(0.1)
print("{}生产了{}个{}".format(name,i+1,item))
q.put(item)
if __name__=="__main__":
q=JoinableQueue()
p1=Process(target=consumer,args=(q,"Lsir"))
p2=Process(target=producter,args=(q,"Wsir","挂件"))
p1.daemon=True
p1.start()
p2.start()
p2.join()
q.join()
print("程序执行结束")