python_day34-优快云博客

本文链接：https://blog.youkuaiyun.com/2301_80367128/article/details/137890862

Semaphore

# ### 信号量 Semaphore 本质上就是锁,只不过是多个进程上多把锁,可以控制上锁的数量
"""Semaphore = lock + 数量 """
from multiprocessing import Semaphore , Process
import time , random
"""
	# 同一时间允许多个进程上5把锁
	sem = Semaphore(5)
	#上锁
	sem.acquire()
	print("执行操作 ... ")
	#解锁
	sem.release()
"""

def singsong_ktv(person,sem):
	# 上锁
	sem.acquire()
	
	print("{}进入了唱吧ktv , 正在唱歌 ~".format(person))
	# 唱一段时间
	time.sleep( random.randrange(4,8) ) # 4 5 6 7
	
	print("{}离开了唱吧ktv , 唱完了 ... ".format(person))
	
	# 解锁
	sem.release()

if __name__ == "__main__":
	sem = Semaphore(5)
	lst = []
		p = Process(target=singsong_ktv , args = (i , sem)		)
		p.start()

事件 (Event)

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

# 控制这个属性的值
    # set()方法     将这个属性的值改成True
    # clear()方法   将这个属性的值改成False
    # is_set()方法  判断当前的属性是否为True  (默认上来是False)
"""

from multiprocessing import Process,Event
import time , random
# 1
'''
e = Event()
# 默认属性值是False.
print(e.is_set()) 
# 判断内部成员属性是否是False 
e.wait()
# 如果是False , 代码程序阻塞
print(" 代码执行中 ...  ")
'''



# 2
'''
e = Event()
# 将这个属性的值改成True
e.set()
# 判断内部成员属性是否是True
e.wait()
# 如果是True , 代码程序不阻塞
print(" 代码执行中 ...  ")

# 将这个属性的值改成False
e.clear()
e.wait()
print(" 代码执行中 .... 2")
'''

# 3
"""
e = Event()
# wait(3) 代表最多等待3秒;
e.wait(3)
print(" 代码执行中 .... 3")
"""

进程队列：

# ### 进程队列
from multiprocessing import Process,Queue
# 引入线程模块; 为了捕捉queue.Empty异常;
import queue


# 1.基本语法
"""顺序: 先进先出,后进后出"""
# 创建进程队列
q = Queue()

# put() 存放
q.put(1)
q.put(2)
q.put(3)

# get() 获取
"""在获取不到任何数据时,会出现阻塞"""
# print(  q.get()  )
# print(  q.get()  )
# print(  q.get()  )
# print(  q.get()  )

# get_nowait() 拿不到数据报异常
"""[windows]效果正常  [linux]不兼容"""
try:
	print(  q.get_nowait()  )
	print(  q.get_nowait()  )
	print(  q.get_nowait()  )
	print(  q.get_nowait()  )
except : #queue.Empty
	pass

# put_nowait() 非阻塞版本的put
# 设置当前队列最大长度为3 ( 元素个数最多是3个 )
"""在指定队列长度的情况下,如果塞入过多的数据,会导致阻塞"""
# q2 = Queue(3)
# q2.put(111)
# q2.put(222)
# q2.put(333)
# q2.put(444)

"""使用put_nowait 在队列已满的情况下,塞入数据会直接报错"""
q2 = Queue(3)
try:
	q2.put_nowait(111)
	q2.put_nowait(222)
	q2.put_nowait(333)
	q2.put_nowait(444)
except:
	pass
	


# 2.进程间的通信IPC

def func(q):
	# 2.子进程获取主进程存放的数据
	res = q.get()
	print(res,"<22>")
	# 3.子进程中存放数据
	q.put("刘一缝")

if __name__ == "__main__":
	q3 = Queue()
	p = Process(target=func,args=(q3,))
	p.start()

	# 1.主进程存入数据
	q3.put("赵凤勇")
	
	# 为了等待子进程把数据存放队列后,主进程在获取数据;
	p.join()
	
	# 4.主进程获取子进程存放的数据
	print(q3.get() , "<33>")

JoinableQueue 队列：

"""
put 存放  
get 获取  
task_done 计算器属性值-1  
join 配合task_done来使用 , 阻塞

put 一次数据, 队列的内置计数器属性值+1
get 一次数据, 通过task_done让队列的内置计数器属性值-1
join: 会根据队列计数器的属性值来判断是否阻塞或者放行
	队列计数器属性是 等于 0 ,  代码不阻塞放行
	队列计数器属性是 不等 0 ,  意味着代码阻塞
"""


from multiprocessing  import JoinableQueue
jq = JoinableQueue()
jq.put("王同培") # +1
jq.put("王伟")   # +2
print(jq.get())
print(jq.get())
# print(jq.get()) 阻塞

jq.task_done()   # -1
jq.task_done()   # -1

jq.join()
print(" 代码执行结束 .... ")


# ### 2.使用JoinableQueue 改造生产着消费者模型
from multiprocessing import Process,Queue
import time,random
# 消费者模型
def consumer(q,name):
	while True:
		# 获取队列中的数据
		food = q.get()
		time.sleep(random.uniform(0.1,1))
		print("{}吃了{}".format(name,food))
		# 让队列的内置计数器属性-1
		q.task_done()


# 生产者模型
def producer(q,name,food):
	for i in range(5):
		time.sleep(random.uniform(0.1,1))
		
		# 展示生产的数据
		print(  "{}生产了{}".format(  name , food+str(i)  )   )
		# 存储生产的数据在队列中
		q.put(food+str(i))
	
if __name__ == "__main__":
	q = JoinableQueue()
	p1 = Process(  target=consumer,args=(q , "赵万里")  )
	p2 = Process(  target=producer,args=(q , "赵沈阳" , "香蕉" )  )
	
	p1.daemon = True
	
	p1.start()
	p2.start()
	
	p2.join()
	# 必须等待队列中的所有数据全部消费完毕,再放行
	q.join()

	print("程序结束 ... ")