day19.进程通信与线程1

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, 'a'])
    c2 = Process(target=consumer, args=[queue,'b' ])
    c3 = Process(target=consumer, args=[queue,'c' ])
    c4 = Process(target=consumer, args=[queue,'d' ])
    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)