1 进程Queue介绍
1 进程间数据隔离，两个进程进行通信，借助于Queue
2 进程间通信：IPC
-借助于Queue实现进程间通信
-借助于文件
-借助于数据库
-借助于消息队列：rabbitmq，kafka....
1.1 基本使用
from multiprocessing import Process,Queue
if __name__ == '__main__':
# maxsize表示Queue的大小是多少，能放多少东西
queue=Queue(3)
## 放数据
queue.put('zhangsan')
queue.put('liss')
queue.put('wwwww')
queue.put('wwwww',timeout=0.1)
# queue.put_nowait('sdafsd')
#
# res=queue.get()
# print(res)
# res=queue.get()
# print(res)
res=queue.get()
# print(res)
# # 卡住
# # res=queue.get()
# res=queue.get_nowait()
# print(res)
'''
# 实例化得到一个对象，数字表示queue的大小(默认不传参，可以当成无限大，但其实有最大值)
queue=Queue(3)
# 放值
# block:是否阻塞
#timeout：等待的时间
queue.put()
#取值
# block:是否阻塞
#timeout：等待的时间
queue.get()
# 不等待，如果满了，就报错
queue.put_nowait()
# 去取值，如果没有值，直接报错
res=queue.get_nowait()
#查看这个queue是否满
queue.full()
#查看queue是否是空的
queue.empty()
# 查看queue中有几个值
queue.qsize()
'''
2 通过Queue实现进程间通信
from multiprocessing import Process,Queue
import os
import time
def task(queue):
print('我这个进程%s开始放数据了'%os.getpid())
time.sleep(10)
queue.put('lqz is handsome')
print('%s我放完了' % os.getpid())
if __name__ == '__main__':
#不写数字，表示可以任意长度
queue=Queue()
p=Process(target=task,args=[queue,])
p.start()
res=queue.get() #会卡在这
print(res)
3 批量生产数据放入Queue再批量取出
from multiprocessing import Process,Queue
import os
def get_task(queue):
res=queue.get()
print('%s这个进程取了数据：%s'%(os.getpid(),res))
def put_task(queue):
queue.put('%s:放了数据'%os.getpid())
if __name__ == '__main__':
queue=Queue(1)
p1=Process(target=put_task,args=[queue])
p2=Process(target=put_task,args=[queue])
p1.start()
p2.start()
p3=Process(target=get_task,args=[queue])
p4=Process(target=get_task,args=[queue])
p3.start()
p4.start()
4 生产者消费者模型(重点)
from multiprocessing import Process, Queue
# import os
#
# import time
# import random
# def producer(queue):
# # 生产的东西，放到Queue中
# for i in range(10):
# data = '%s这个厨师，整了第%s个包子' % (os.getpid(), i)
# print(data)
# # 模拟一下延迟
# time.sleep(random.randint(1,3))
# queue.put('第%s个包子'%i)
#
#
# def consumer(queue):
# # 消费者从queue中取数据，消费（吃包子）
# while True:
#
# res=queue.get()
# # 模拟一下延迟
# time.sleep(random.randint(1, 3))
# print('%s这个消费者，吃了%s'%(os.getpid(),res))
#
#
#
# if __name__ == '__main__':
# queue=Queue(3)
# p=Process(target=producer,args=[queue,])
# p.start()
#
# p1=Process(target=consumer,args=[queue,])
# p1.start()
###### 改良（生产者以及不生产东西了，但是消费者还在等着拿）
# import os
#
# import time
# import random
# def producer(queue):
# # 生产的东西，放到Queue中
# for i in range(10):
# data = '%s这个厨师，整了第%s个包子' % (os.getpid(), i)
# print(data)
# # 模拟一下延迟
# time.sleep(random.randint(1,3))
# queue.put('第%s个包子'%i)
# # 生产完了，在queue中放一个None
# queue.put(None)
#
#
# def consumer(queue):
# # 消费者从queue中取数据，消费（吃包子）
# while True:
#
# res=queue.get()
# if not res:break # 如果去到空，说明打烊了（生产者不生产了），退出
# # 模拟一下延迟
# time.sleep(random.randint(1, 3))
# print('%s这个消费者，吃了%s'%(os.getpid(),res))
#
#
#
# if __name__ == '__main__':
# queue=Queue(3)
# p=Process(target=producer,args=[queue,])
# p.start()
#
# p1=Process(target=consumer,args=[queue,])
# p1.start()
#### 把put none 放在主进程中执行
import os
# import time
# import random
# def producer(queue):
# # 生产的东西，放到Queue中
# for i in range(10):
# data = '%s这个厨师，整了第%s个包子' % (os.getpid(), i)
# print(data)
# # 模拟一下延迟
# time.sleep(random.randint(1,3))
# queue.put('第%s个包子'%i)
#
#
#
# def consumer(queue):
# # 消费者从queue中取数据，消费（吃包子）
# while True:
#
# res=queue.get()
# if not res:break # 如果去到空，说明打烊了（生产者不生产了），退出
# # 模拟一下延迟
# time.sleep(random.randint(1, 3))
# print('%s这个消费者，吃了%s'%(os.getpid(),res))
#
#
#
# if __name__ == '__main__':
# queue=Queue(3)
# p=Process(target=producer,args=[queue,])
# p.start()
#
# p1=Process(target=consumer,args=[queue,])
# p1.start()
#
# # 如果把put None放在这，会有问题
# # 主进程会先执行这句话，消费进程读到None，直接结束，生产者进程没有结束，于是生产一直在生产，消费已经不消费了
# # 直到Queue满了，就一直卡在这了
# # queue.put(None)
#
# ### 现在就要放在这，你把问题解决
# p.join()
# queue.put(None)
5 多个生产者多个消费者的生产者消费者模型
# 多个生产者在生产，多个消费者在消费
# import time
# import random
# def producer(queue,food):
# # 生产的东西，放到Queue中
# for i in range(10):
# data = '%s这个厨师，做了第%s个%s' % (os.getpid(), i,food)
# print(data)
# # 模拟一下延迟
# time.sleep(random.randint(1,3))
# queue.put('第%s个%s'%(i,food))
#
#
# def consumer(queue):
# # 消费者从queue中取数据，消费（吃包子）
# while True:
# res=queue.get()
# if not res:break # 如果去到空，说明打烊了（生产者不生产了），退出
# # 模拟一下延迟
# time.sleep(random.randint(1, 3))
# print('%s这个消费者，吃了%s'%(os.getpid(),res))
#
#
#
# if __name__ == '__main__':
# queue=Queue(3)
# ##起了三个生产者
# p1=Process(target=producer,args=[queue,'包子'])
# p2=Process(target=producer,args=[queue,'骨头'])
# p3=Process(target=producer,args=[queue,'泔水'])
# p1.start()
# p2.start()
# p3.start()
#
#
#
# # 起了两个消费者
# c1=Process(target=consumer,args=[queue,])
# c2=Process(target=consumer,args=[queue,])
# c1.start()
# c2.start()
#
# ##等三个生产者都生产完，放三个None
# p1.join()
# p2.join()
# p3.join()
# queue.put(None)
# queue.put(None)
# queue.put(None)
##如果消费者多，比生产者多出来的消费者不会停
import time
import random
def producer(queue, food,name):
# 生产的东西，放到Queue中
for i in range(10):
data = '%s:这个厨师，做了第%s个%s' % (name, i, food)
print(data)
# 模拟一下延迟
time.sleep(random.randint(1, 3))
queue.put('第%s个%s' % (i, food))
def consumer(queue,name):
# 消费者从queue中取数据，消费（吃包子）
while True:
try:
res = queue.get(timeout=20)
# 模拟一下延迟
time.sleep(random.randint(1, 3))
print('%s这个消费者，吃了%s' % (name, res))
except Exception as e:
print(e)
break
if __name__ == '__main__':
queue = Queue(3)
##起了三个生产者
p1 = Process(target=producer, args=[queue, '包子','egon'])
p2 = Process(target=producer, args=[queue, '骨头','lqz'])
p3 = Process(target=producer, args=[queue, '泔水','jsason'])
p1.start()
p2.start()
p3.start()
# 起了两个消费者
c1 = Process(target=consumer, args=[queue, '孟良'])
c2 = Process(target=consumer, args=[queue,'池劲涛' ])
c3 = Process(target=consumer, args=[queue,'池劲涛' ])
c4 = Process(target=consumer, args=[queue,'池劲涛' ])
c1.start()
c2.start()
c3.start()
c4.start()
6 进程间数据共享（了解）
from multiprocessing import Process,Manager,Lock
# 魔法方法：类内以__开头__结尾的方法，都叫魔法方法,某种情况下会触发它的执行
'''
__init__ ：类()触发
__new__：
__getattr__
__setattr__
__getitem__
__setitem__
'''
# def task(dic,lock):
# # lock.acquire()
# # dic['count']-=1
# # lock.release()
# with lock:
# dic['count'] -= 1
#
# if __name__ == '__main__':
# lock = Lock()
# with Manager() as m:
# # 如果直接定义dict，这个dict在多个进程中其实是多份，进程如果改，只改了自己的
# #如果定义的是m.dict({'count': 100})，多个进程之间就可以共享这个数据
# dic = m.dict({'count': 100})
#
# p_l = []
# for i in range(100):
# p = Process(target=task, args=(dic, lock))
# p_l.append(p)
# p.start()
# for p in p_l:
# p.join()
def task(dic,lock):
with lock:
dic['count'] -= 1
if __name__ == '__main__':
lock = Lock()
dic={'count':100}
p_l = []
for i in range(100):
p = Process(target=task, args=(dic, lock))
p_l.append(p)
p.start()
for p in p_l:
p.join()
print(dic)
7 线程概念
如果把我们上课的过程看成一个进程的话，那么我们要做的是耳朵听老师讲课，手上还要记笔记，脑子还要思考问题，这样才能高效的完成听课的任务。而如果只提供进程这个机制的话，上面这三件事将不能同时执行，同一时间只能做一件事，听的时候就不能记笔记，也不能用脑子思考，这是其一；如果老师在黑板上写演算过程，我们开始记笔记，而老师突然有一步推不下去了，阻塞住了，他在那边思考着，而我们呢，也不能干其他事，即使你想趁此时思考一下刚才没听懂的一个问题都不行，这是其二
#进程是资源分配的最小单位，线程是CPU调度的最小单位。每一个进程中至少有一个线程。
from threading import Thread
from queue import Queue
import os
import time
def task():
time.sleep(3)
print('我是子线程执行的')
print(os.getpid())
if __name__ == '__main__':
# 启动线程
ctime = time.time()
t = Thread(target=task)
t.start()
# task()
time.sleep(3)
print(os.getpid())
print(time.time() - ctime)
总结
1 Queue:进程间通信
-实例化得到一个对象
-对象.put()
-对象.get()
2 生产者消费者模型
3 通过共享变量来共享数据（进程间数据是隔离的）
-Manager实现多个进程操作同一个变量
-加锁
4 线程，每个进程下最少有一个线程，cup调度的最小单位
5 python如何开启线程
