Python多进程part2

一、lock锁

上锁和解锁是一对，只上锁不解锁会发生死锁现象(代码阻塞，不往下执行)
互斥锁：互斥锁是进程之间的相互排斥，谁先抢到这个锁资源就先使用，后抢到后使用

1、基本用法：

我们先来看看只上锁不解锁情况：

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("执行程序 ...")

运行结果：

如图，解锁后三个进程执行完毕。

2、模拟抢票

模拟一张票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()

运行结果：

如图，因为锁的存在，将每个人的抢票的动作锁死，多进程从异步变成了同步，故不会发生多个人抢到票的情况

总结：
创建进程时，仍然是异步并发，在执行到上所操作时，多个进程之间变成了同步程序，先来的先上锁,先执行,后来的进程后上锁,后执行

3、Semaphore信号量

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()

运行结果：

二、事件

阻塞事件：

• e=Event() 生成时间对象e
• e.wait() 动态给程序加阻塞，程序当中是否加阻塞完全取决于该对象中的is_set() [默认返回值是False]
• 如果是True,不加阻塞
• 如果是False,加阻塞

控制这个属性的值：
set()方法 将这个属性的值改成True
clear()方法 将这个属性的值改为False
is_set()方法 判断当前属性是否为True

1、手动添加阻塞

from multiprocessing import Process,Event
import time
e=Event()
print(e.is_set())
e.wait()
print("程序执行")

运行结果：

2、将属性值进行变更

from multiprocessing import Process,Event
import time
e=Event()
e.set()
print(e.is_set())
e.wait()
print("程序执行")

运行结果：

3、wait可以加参数，表示最大等待时间

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("程序执行")

运行结果：

4、手动添加动态堵塞实现交通灯

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,))

运行结果：

三、进程队列

队列特点：先进先出，后进后出

1、基本写法

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)

运行结果：

如果队列中已没有数据，会发生阻塞

2、设置队列长度

队列可设置长度，超出长度将发生阻塞

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)

运行结果：

如图，发生阻塞

3、进程之间的数据互享

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函数,会根据队列计数器来判断是阻塞还是放行

• 队列计数器 = 0 , 意味着放行
• 队列计数器 != 0 , 意味着阻塞

改写上例：

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("程序执行结束")

运行结果：