7.17python

1.事件:

# !/usr/bin/env python
# !--*--coding:utf-8 --*--
# !@Time    :2018/7/17 10:38
# !@Author   TrueNewBee

# 事件:通过一个信号 来控制 多个进程 同时 执行或者阻塞
# 一个信号可以使所有的进程都进入阻塞状态
# 也可以控制所有进程的解除阻塞
# 一个事件被创建之后,默认是阻塞状态

# set 和 clear
#   分别用来修改一个事件的状态 True或者False
# is_set 用来查看一个事件的状态
# wait   是根据事件的状态来解决自己是否在wait处阻塞
#        False阻塞  True不阻塞

# from multiprocessing import Event
#
#
# def event():
#     e = Event()  # 创建一个事件
#     print(e.is_set())  # 查看一个事件的状态,默认设置成阻塞
#     e.set()  # 将这个事件的状态改为True
#     print(e.is_set())
#     e.wait()  # 是依据e.is_set()的值来决定是否阻塞
#     print(123456)
#     e.clear()  # 将这个事件的状态改为False
#     print(e.is_set())
#     e.wait()    # 等待事件的信号被编程True
#     print('*'*10)
#
#
# if __name__ == '__main__':
#     event()

# 红绿灯事件
# 用事件控制信号,控制进程
import time
import random
from multiprocessing import Process
from multiprocessing import Event

def cars(e2, i1):
    """创建一个车"""
    if not e2.is_set():
        print("car%i1在等待" % i1)
        e2.wait()  # 阻塞,直到得到一个 事件状态变成True的信号
    print("car%s通过" % i1)

def light(e1):
    """灯是独立的进程"""
    while True:
        if e1.is_set():
            time.sleep(2)
            e1.clear()
            print("绿灯亮了")
        else:
            e1.set()
            print("红灯亮了")
        time.sleep(2)

if __name__ == '__main__':
    e = Event()
    traffic = Process(target=light, args=(e, ))
    traffic.start()
    for i in range(20):
        car = Process(target=cars, args=(e, i))
        car.start()
        time.sleep(random.random())

2.队列

# !/usr/bin/env python
# !--*--coding:utf-8 --*--
# !@Time    :2018/7/17 12:19
# !@Author   TrueNewBee

# import time
# from multiprocessing import Queue
#
#
# q = Queue(5)
# q.put(1)    # 向队列里面放值
# q.put(2)
# q.put(3)
# q.put(4)
# q.put(5)
# # 如果队列满了再添加则出现堵塞
# print(q.full())  # 队列是否满了
# print(q.get())  # 取出来数
# print(q.get())
# print(q.get())
# print(q.get())
# print(q.get())
# # 如果队列全取出了再去将出现阻塞
# print(q.empty())    # 判断队列是否为空
# while True:
#     """检查队列是否为空"""
#     try:
#         q.get_nowait()
#     except :
#         print("队列已空")
#         time.sleep(1)

from multiprocessing import Process
from multiprocessing import Queue

# 队列生产和消费数据
def produce(q1):
    """队列存储数据"""
    q1.put('hello')

def consume(q2):
    """队列消费数据"""
    print(q2.get())

if __name__ == '__main__':
    q = Queue()
    p = Process(target=produce,args=(q, ))
    p.start()
    c = Process(target=consume, args=(q, ))
    c.start()

3.生产者和消费者 joinableQueue模型:

# !/usr/bin/env python
# !--*--coding:utf-8 --*--
# !@Time    :2018/7/17 15:04
# !@Author   TrueNewBee

# 队列
# 生产者消费者模型  解决供需不平衡的问题
import time
import random
from multiprocessing import Process, JoinableQueue

def consumer(name, q1):
    """负责消费生产的东西"""
    while True:
        food = q1.get()
        if food is None:     # 判断为空则停止这个循环
            print('%s获取到一个空' % name)
            break
        print('\033[31m%s消费了%s\033[0m' % (name, food))
        time.sleep(random.randint(0, 2))
        q1.task_done()  # 提交回执 count - 1

def producer(name, food, q1):
    """负责生产包子"""
    for i in range(10):
        time.sleep(random.randint(0, 2))
        f = '%s生产了%s%s' % (name, food, i)
        print(f)
        q1.put(f)
    q1.join()   # 阻塞,直到一个队列中的数据 全部被执行完毕

if __name__ == '__main__':
    q = JoinableQueue(20)
    p1 = Process(target=producer, args=('Egon', '包子', q))
    p2 = Process(target=producer, args=('WuSir', '泔水', q))
    c1 = Process(target=consumer, args=('jinBoss', q))
    c2 = Process(target=consumer, args=('alex', q))
    p1.start()
    p2.start()
    c1.daemon = True  # 成为守护进程,主进程中的代码执行完毕之后,子进程自动结束
    c2.daemon = True
    c1.start()
    c2.start()
    p1.join()   # 感知一个进程结束
    p2.join()

# 在消费者这一端
    # 每次获取一个数据
    # 处理一个数据
    # 发送一个记号:标志一个数据被处理成功

# 在生产者这一端
    # 每一次生产一个数据
    # 且每一次生产的数据放在队列中
    # 在队列中刻上一个记号
    # 当生产者全部生产完毕后
    # join信号: 已经停止生产数据了
    # 且要等待之前被刻上的记号都被消费完
    # 当数据都被处理完时,join阻塞结束

# consumer 中把所有的任务消耗完
# produce 端的join感知到,停止阻塞
# 所有的producer进程结束
# 主进程中的p.join结束
# 守护进程(消费者进程)结束

4. 生产者和消费者 Queue模型:

# !/usr/bin/env python
# !--*--coding:utf-8 --*--
# !@Time    :2018/7/17 15:04
# !@Author   TrueNewBee

# 队列
# 生产者消费者模型  解决供需不平衡的问题
import time
import random
from multiprocessing import Queue, Process

def consumer(name, q1):
    """负责消费生产的东西"""
    while True:
        food = q1.get()
        if food is None:    # 判断为空则停止这个循环
            print('%s获取到一个空' % name)
            break
        print('\033[31m%s消费了%s\033[0m' % (name, food))
        time.sleep(random.randint(0, 2))

def producer(name, food, q1):
    """负责生产包子"""
    for i in range(10):
        time.sleep(random.randint(0, 2))
        f = '%s生产了%s%s' % (name, food, i)
        print(f)
        q1.put(f)

if __name__ == '__main__':
    q = Queue(20)
    p1 = Process(target=producer, args=('Egon', '包子', q))
    p2 = Process(target=producer, args=('WuSir', '泔水', q))
    c1 = Process(target=consumer, args=('jinBoss', q))
    c2 = Process(target=consumer, args=('alex', q))
    p1.start()
    p2.start()
    c1.start()
    c2.start()
    p1.join()   # 感知一个进程结束
    p2.join()
    q.put(None)
    q.put(None)