铁乐学python_Day39_多进程和multiprocess模块2

铁乐学python_Day39_多进程和multiprocess模块2

锁 —— multiprocess.Lock (进程同步）

之前我们千方百计实现了程序的异步，让多个任务可以同时在几个进程中并发处理，

但是它们之间的运行没有顺序，一旦开启也不受我们控制。

尽管并发编程能让我们更加充分的利用IO资源，但是也会带来新的问题。

当多个进程使用同一份数据资源的时候，就会引发数据安全或顺序混乱问题。

遇到数据、安全比速度重要的场景，我们就需要将进程变回受同步控制。

例：
#!/usr/bin/env python
# _*_ coding: utf-8 _*_

import time
import random
from multiprocessing import Process

def work(person, n):
    print('%s 开始闯黄道十二宫中的 [第%s宫] 了！' % (person, n))
    time.sleep(random.random())
    print('%s 闯过了 [第%s宫]！' % (person, n))

if __name__ == '__main__':
    start = ['星矢', '一辉', '冰河', '紫龙', '阿瞬']
    for i in range(1, 13):
        role = random.choice(start)
        p = Process(target=work, args=(role, i))
        p.start()

星矢 开始闯黄道十二宫中的 [第4宫] 了！
阿瞬 开始闯黄道十二宫中的 [第1宫] 了！
星矢 开始闯黄道十二宫中的 [第6宫] 了！
一辉 开始闯黄道十二宫中的 [第5宫] 了！
紫龙 开始闯黄道十二宫中的 [第2宫] 了！
紫龙 开始闯黄道十二宫中的 [第7宫] 了！
星矢 开始闯黄道十二宫中的 [第3宫] 了！
冰河 开始闯黄道十二宫中的 [第9宫] 了！
紫龙 开始闯黄道十二宫中的 [第8宫] 了！
一辉 开始闯黄道十二宫中的 [第11宫] 了！
阿瞬 开始闯黄道十二宫中的 [第12宫] 了！
冰河 开始闯黄道十二宫中的 [第10宫] 了！
一辉 闯过了 [第5宫]！
紫龙 闯过了 [第7宫]！
紫龙 闯过了 [第8宫]！
星矢 闯过了 [第4宫]！
一辉 闯过了 [第11宫]！
阿瞬 闯过了 [第12宫]！
冰河 闯过了 [第9宫]！
冰河 闯过了 [第10宫]！
紫龙 闯过了 [第2宫]！
阿瞬 闯过了 [第1宫]！
星矢 闯过了 [第6宫]！
星矢 闯过了 [第3宫]！

例：加锁后
#!/usr/bin/env python
# _*_ coding: utf-8 _*_

import time
import random
from multiprocessing import Process, Lock

def work(lock, person, n):
    # 加锁由并发变成了串行，牺牲了运行效率，但避免了对资源的竞争
    lock.acquire()
    print('%s 开始闯黄道十二宫中的 [第%s宫] 了！' % (person, n))
    time.sleep(random.random())
    print('%s 闯过了 [第%s宫]！' % (person, n))
    # lock中的方法，acquire和release可说是一对组合，先加锁再解锁并将锁重置
    lock.release()

if __name__ == '__main__':
    # Lock得先创造一个实例出来，才方便使用它当中的方法
    lock = Lock()
    start = ['星矢', '一辉', '冰河', '紫龙', '阿瞬']
    for i in range(1, 13):
        role = random.choice(start)
        p = Process(target=work, args=(lock, role, i))
        p.start()

星矢 开始闯黄道十二宫中的 [第2宫] 了！
星矢 闯过了 [第2宫]！
一辉 开始闯黄道十二宫中的 [第4宫] 了！
一辉 闯过了 [第4宫]！
紫龙 开始闯黄道十二宫中的 [第1宫] 了！
紫龙 闯过了 [第1宫]！
冰河 开始闯黄道十二宫中的 [第5宫] 了！
冰河 闯过了 [第5宫]！
星矢 开始闯黄道十二宫中的 [第8宫] 了！
星矢 闯过了 [第8宫]！
星矢 开始闯黄道十二宫中的 [第3宫] 了！
星矢 闯过了 [第3宫]！
冰河 开始闯黄道十二宫中的 [第6宫] 了！
冰河 闯过了 [第6宫]！
冰河 开始闯黄道十二宫中的 [第9宫] 了！
冰河 闯过了 [第9宫]！
阿瞬 开始闯黄道十二宫中的 [第7宫] 了！
阿瞬 闯过了 [第7宫]！
冰河 开始闯黄道十二宫中的 [第12宫] 了！
冰河 闯过了 [第12宫]！
阿瞬 开始闯黄道十二宫中的 [第10宫] 了！
阿瞬 闯过了 [第10宫]！
星矢 开始闯黄道十二宫中的 [第11宫] 了！
星矢 闯过了 [第11宫]！

同步控制
只要用到了锁，锁之内的代码就变成同步的了。
锁 ：控制一段代码，同一时间，只能被一个进程执行。

上面这种情况虽然使用加锁的形式实现了顺序的执行，
但是程序又重新变成串行了，这样确实会浪费了时间，却保证了数据的安全。
接下来，我们以模拟抢票为例，来看看数据安全的重要性。 

例：

#!/usr/bin/env python
# _*_ coding: utf-8 _*_

'''
文件db的内容为：{"ticket":2}
注意一定要用双引号，不然json无法识别。
模拟并发运行，效率高， 但竞争对同一个文件写入，数据写入混乱。
不安全，保障不了数据的准确。
'''

import time
import json
import random
from multiprocessing import Process

def search():
    dic = json.load(open('db'))
    print('\033[32m剩余票数%s\033[0m' % dic['ticket'])

def get():
    dic = json.load(open('db'))
    # 模拟读数据的网络延迟
    time.sleep(random.random())
    if dic['ticket'] > 0:
        dic['ticket'] -= 1
        # 模拟写数据的网络延迟
        time.sleep(random.random())
        json.dump(dic, open('db', 'w'))
        print('\033[31m购票成功\033[0m')

def task():
    search()
    get()

if __name__ == '__main__':
    # 模拟并发10个客户端抢票
    for i in range(10):
        p = Process(target=task)
        p.start()

剩余票数2
剩余票数2
剩余票数2
剩余票数2
剩余票数2
剩余票数2
剩余票数2
剩余票数2
剩余票数2
剩余票数2
购票成功
购票成功
购票成功
购票成功
购票成功
购票成功
购票成功
购票成功
购票成功
购票成功

可见数据并不准确。需要加锁来保证数据安全和准确性 。

例：加锁后

#!/usr/bin/env python
# _*_ coding: utf-8 _*_

'''
文件db的内容为：{"ticket":2}
注意一定要用双引号，不然json无法识别。
模拟对购票行为进行加锁安全，保障了数据的准确和安全。
'''

import time
import json
import random
from multiprocessing import Process,Lock

def search():
    dic = json.load(open('db'))
    print('\033[32m剩余票数%s\033[0m' % dic['ticket'])

def get():
    dic = json.load(open('db'))
    # 模拟读数据的网络延迟
    time.sleep(random.random())
    if dic['ticket'] > 0:
        dic['ticket'] -= 1
        # 模拟写数据的网络延迟
        time.sleep(random.random())
        json.dump(dic, open('db', 'w'))
        print('\033[31m购票成功\033[0m')

def task(lock):
    # 注意，别忘了传Lock的实例化对象进来
    search()
    # 搜索不涉及写入操作，且搜索需要速度快，可以不加锁
    # 到抢票和写入购票成功，余票减1，就得对操作数据的代码加锁了
    lock.acquire()
    get()
    lock.release()

if __name__ == '__main__':
    lock = Lock()
    # 模拟并发10个客户端抢票
    for i in range(10):
        p = Process(target=task, args=(lock,))
        p.start()

剩余票数2
剩余票数2
剩余票数2
剩余票数2
剩余票数2
剩余票数2
剩余票数2
剩余票数2
剩余票数2
剩余票数2
购票成功
购票成功

例：较为完善提示的模拟抢票（加锁）

#!/usr/bin/env python
# _*_ coding: utf-8 _*_

'''
文件db的内容为：{"ticket":2}
注意一定要用双引号，不然json无法识别。
模拟对购票行为进行加锁安全，保障了数据的准确和安全。
'''

import json
import time
import random
from multiprocessing import Process, Lock

def check_ticket(i):
    with open('db') as f:
        ticket_count = json.load(f)
    print('person%s查询当前余票 ：' % i, ticket_count['ticket'])

def buy_ticket(i, lock):
    check_ticket(i)
    lock.acquire()
    with open('db') as f:
        ticket_count = json.load(f)
    time.sleep(random.random())
    if ticket_count['ticket'] > 0:
        print('person%s购票成功' % i)
        ticket_count['ticket'] -= 1
    else:
        print('余票不足，person%s购票失败' % i)
    time.sleep(random.random())
    with open('db', 'w') as f:
        json.dump(ticket_count, f)
    lock.release()

if __name__ == '__main__':
    lock = Lock()
    for i in range(5):
        Process(target=buy_ticket, args=[i, lock]).start()

person2查询当前余票 ： 2
person3查询当前余票 ： 2
person1查询当前余票 ： 2
person0查询当前余票 ： 2
person4查询当前余票 ： 2
person2购票成功
person3购票成功
余票不足，person1购票失败
余票不足，person0购票失败
余票不足，person4购票失败

加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。

虽然可以用文件共享数据实现进程间通信，但问题是：

1.效率低（共享数据基于文件，而文件是硬盘上的数据）

2.需要自己加锁处理

因此我们最好找寻一种解决方案能够兼顾：

1、效率高（多个进程共享一块内存的数据）

2、帮我们处理好锁问题。

这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。

队列和管道都是将数据存放于内存中

队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，

我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，

避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。

信号量 —— multiprocess.Semaphore

互斥锁同时只允许一个线程更改数据，而信号量Semaphore是同时允许一定数量的线程更改数据 。

例如商场里有4个迷你唱吧，所以同时可以进去4个人，如果来了第五个人就要在外面等待，等到有人出来才能再进去玩。

实现：

信号量同步基于内部计数器，每调用一次acquire()，计数器减1；

每调用一次release()，计数器加1.当计数器为0时，acquire()调用被阻塞。

这是迪科斯彻（Dijkstra）信号量概念P()和V()的Python实现。

信号量同步机制适用于访问像服务器这样的有限资源。

信号量与进程池的概念很像，但是要区分开，信号量涉及到加锁的概念。

例：KTV迷你唱吧
#!/usr/bin/env python
# _*_ coding: utf-8 _*_

# KTV 4个房子
import time
import random
from multiprocessing import Process, Semaphore

def ktv(i, sem):
    sem.acquire()
    print('person %s 进来唱歌了' % i)
    time.sleep(random.randint(1, 5))
    print('person %s 从ktv出去了' % i)
    sem.release()

if __name__ == '__main__':
    sem = Semaphore(4)
    for i in range(10):
        Process(target=ktv, args=(i, sem)).start()

# 锁+计数器
# .acquire() 计数器-1
# 计数器减为0 = 阻塞
# .release() 计数器+1

person 0 进来唱歌了
person 3 进来唱歌了
person 1 进来唱歌了
person 2 进来唱歌了
person 2 从ktv出去了
person 4 进来唱歌了
person 0 从ktv出去了
person 6 进来唱歌了
person 3 从ktv出去了
person 7 进来唱歌了
person 7 从ktv出去了
person 5 进来唱歌了
person 1 从ktv出去了
person 8 进来唱歌了
person 8 从ktv出去了
person 9 进来唱歌了
person 4 从ktv出去了
person 6 从ktv出去了
person 5 从ktv出去了
person 9 从ktv出去了

事件 —— multiprocess.Event

python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。

事件处理的机制：
全局定义了一个“Flag”，如果“Flag”值为 False，
那么当程序执行 event.wait 方法时就会阻塞，
如果“Flag”值为True，那么event.wait 方法时便不再阻塞。

clear：将“Flag”设置为False
set：将“Flag”设置为True

例：红绿灯
#!/usr/bin/env python
# _*_ coding: utf-8 _*_

import time
import random
from multiprocessing import Process, Event

def car(i,e):  # 感知状态的变化
    if not e.is_set():    # 当前这个事件的状态如果是False
        print('car%s正在等待'%i)  # 这辆车正在等待通过路口
    e.wait()    # 阻塞 直到有一个e.set行为  # 等红灯
    print('car%s通过路口'%i)

def traffic_light(e):  # 修改事件的状态
    print('\033[1;31m红灯亮\033[0m')
    # 事件在创立之初的状态是False，相当于程序中的红灯
    time.sleep(2)  # 红灯亮2s
    while True:
        if not e.is_set():  # False
            print('\033[1;32m绿灯亮\033[0m')
            e.set()
        elif e.is_set():
            print('\033[1;31m红灯亮\033[0m')
            e.clear()
        time.sleep(2)

if __name__ == '__main__':
    e = Event()
    Process(target=traffic_light, args=[e, ]).start()
    for i in range(10):
        time.sleep(random.randrange(0, 5, 2))
        Process(target=car, args=[i, e]).start()

红灯亮
绿灯亮
红灯亮
car1正在等待
car2正在等待
绿灯亮
car2通过路口
car1通过路口
红灯亮
car3正在等待
car4正在等待
绿灯亮
car4通过路口
car3通过路口
红灯亮
car5正在等待
绿灯亮
car5通过路口
car6通过路口
car8通过路口
car7通过路口
红灯亮
car9正在等待
car10正在等待
绿灯亮
car10通过路口
car9通过路口
car11通过路口
红灯亮
绿灯亮
car12通过路口
car13通过路口
红灯亮
绿灯亮
car14通过路口
红灯亮
绿灯亮
car15通过路口
红灯亮
car16正在等待
car17正在等待
绿灯亮
car17通过路口
car16通过路口
car18通过路口
car19通过路口
car20通过路口
红灯亮
绿灯亮

进程间通信——队列和管道 Queue和Pipe

IPC(Inter-Process Communication)

队列
概念介绍
创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。 

Queue([maxsize])
创建共享的进程队列。
参数 ：maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。
底层队列使用管道和锁定实现。
另外，还需要运行支持线程以便队列中的数据传输到底层管道中。 

Queue的实例q具有以下方法：

q.get( [ block [ ,timeout ] ] )
返回q中的一个项目。如果q为空，此方法将阻塞，直到队列中有项目可用为止。
block用于控制阻塞行为，默认为True. 如果设置为False，将引发Queue.Empty异常（定义在Queue模块中）。
timeout是可选超时时间，用在阻塞模式中。
如果在制定的时间间隔内没有项目变为可用，将引发Queue.Empty异常。

q.get_nowait( )
同q.get(False)方法。

q.put(item [, block [,timeout ] ] )
将item放入队列。如果队列已满，此方法将阻塞至有空间可用为止。
block控制阻塞行为，默认为True。
如果设置为False，将引发Queue.Empty异常（定义在Queue库模块中）。
timeout指定在阻塞模式中等待可用空间的时间长短。超时后将引发Queue.Full异常。

q.qsize()
返回队列中目前项目的正确数量。
此函数的结果并不可靠，因为在返回结果和在稍后程序中使用结果之间，队列中可能添加或删除了项目。
在某些系统上，此方法可能引发NotImplementedError异常。

q.empty()
如果调用此方法时 q为空，返回True。如果其他进程或线程正在往队列中添加项目，结果是不可靠的。
也就是说，在返回和使用结果之间，队列中可能已经加入新的项目。

q.full()
如果q已满，返回为True. 由于线程的存在，结果也可能是不可靠的（参考q.empty（）方法）。。

q.close()
关闭队列，防止队列中加入更多数据。
调用此方法时，后台线程将继续写入那些已入队列但尚未写入的数据，但将在此方法完成时马上关闭。
如果q被垃圾收集，将自动调用此方法。
关闭队列不会在队列使用者中生成任何类型的数据结束信号或异常。
例如，如果某个使用者正被阻塞在get（）操作上，关闭生产者中的队列不会导致get（）方法返回错误。

q.cancel_join_thread()
不会再进程退出时自动连接后台线程。这可以防止join_thread()方法阻塞。

q.join_thread()
连接队列的后台线程。此方法用于在调用q.close()方法后，等待所有队列项被消耗。
默认情况下，此方法由不是q的原始创建者的所有进程调用。
调用q.cancel_join_thread()方法可以禁止这种行为。

生产者消费者模型

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。

该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

为什么要使用生产者和消费者模式？

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。

在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。

同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。

为了解决这个问题于是引入了生产者和消费者模式。

什么是生产者消费者模式？

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。

生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，

所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，

消费者不找生产者要数据，而是直接从阻塞队列里取，

阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

例：
#!/usr/bin/env python
# _*_ coding: utf-8 _*_

import time
import random
from multiprocessing import Process, Queue

# 消费者
def consumer(q, name):
    # 吃货，一直吃
    while True:
        food = q.get()
        # 当food取值为done时，消费者跳出循环停止消费
        if food == 'done':break
        # 模拟消费的延迟
        time.sleep(random.random())
        print('%s 吃了 %s' % (name, food))

def producer(q, name, food):
    # 与消费者一直吃不同，生产者一开始就是在有限范围内循环，所以用for
    for i in range(1, 6):
        time.sleep(random.random())
        print('%s 生产出%s%s' % (name, food, i))
        q.put('%s%s' % (food, i))

if __name__ == '__main__':
    # 创建一个队列
    q = Queue()
    p1 = Process(target=producer, args=[q, '蜜蜂', '蜂蜜'])
    p2 = Process(target=producer, args=[q, '苹果树', '苹果'])
    p1.start()
    p2.start()
    Process(target=consumer, args=[q, '铁乐']).start()
    Process(target=consumer, args=[q, '猫']).start()
    p1.join()
    p2.join()
    # 有两个消费者，就要在队列加入两个标志结束的done
    q.put('done')
    q.put('done')

蜜蜂 生产出蜂蜜1
蜜蜂 生产出蜂蜜2
猫 吃了 蜂蜜1
苹果树 生产出苹果1
猫 吃了 苹果1
铁乐 吃了 蜂蜜2
蜜蜂 生产出蜂蜜3
苹果树 生产出苹果2
铁乐 吃了 苹果2
猫 吃了 蜂蜜3
蜜蜂 生产出蜂蜜4
苹果树 生产出苹果3
猫 吃了 苹果3
铁乐 吃了 蜂蜜4
蜜蜂 生产出蜂蜜5
苹果树 生产出苹果4
苹果树 生产出苹果5
猫 吃了 蜂蜜5
铁乐 吃了 苹果4
猫 吃了 苹果5

JoinableQueue([maxsize])
创建可连接的共享进程队列。
这就像是一个Queue对象，但队列允许项目的使用者通知生产者项目已经被成功处理。
通知进程是使用共享的信号和条件变量来实现的。

JoinableQueue的实例p除了与Queue对象相同的方法之外，还具有以下方法：

q.task_done()
使用者使用此方法发出信号，表示q.get()返回的项目已经被处理。
如果调用此方法的次数大于从队列中删除的项目数量，将引发ValueError异常。

q.join()
生产者将使用此方法进行阻塞，直到队列中所有项目均被处理。
阻塞将持续到为队列中的每个项目均调用q.task_done()方法为止。
下面的例子说明如何建立永远运行的进程，使用和处理队列上的项目。生产者将项目放入队列，并等待它们被处理。

#!/usr/bin/env python
# _*_ coding: utf-8 _*_

from multiprocessing import Process, JoinableQueue
import time, random, os

def consumer(q):
    while True:
        food = q.get()
        time.sleep(random.randint(1, 3))
        print('\033[32m%s 吃 %s\033[0m' % (os.getpid(), food))
        q.task_done()
        # 向q.join()发送一次信号,证明一个数据已经被取走了，
        # 和普通队列不同的是用不到发送标志结束的信号来break终止循环

def producer(name, q):
    for i in range(1, 6):
        time.sleep(random.randint(1, 3))
        res = '%s%s' % (name, i)
        q.put(res)
        print('\033[34m%s 生产了 %s\033[0m' % (os.getpid(), res))
    q.join()  # 生产完毕，使用此方法进行阻塞，直到队列中所有项目均被处理。

if __name__ == '__main__':
    # 创建JoinableQueue类型队列
    q = JoinableQueue()
    # 生产者们:即厨师们
    p1 = Process(target=producer, args=('蒸水蛋', q))
    p2 = Process(target=producer, args=('清蒸鱼', q))
    p3 = Process(target=producer, args=('酱油鸡', q))

    # 消费者们:即吃货们
    c1 = Process(target=consumer, args=(q,))
    c2 = Process(target=consumer, args=(q,))
    # 设为守护进程
    c1.daemon = True
    c2.daemon = True

    # 开始
    p_l = [p1, p2, p3, c1, c2]
    for p in p_l:
        p.start()

    p1.join()
    p2.join()
    p3.join()
    print('主进程结束')

    # 主进程等--->p1,p2,p3等---->c1,c2
    # p1,p2,p3结束了,证明c1,c2肯定全都收完了p1,p2,p3发到队列的数据
    # 因而c1,c2也没有存在的价值了,不需要继续阻塞在进程中影响主进程了。应该随着主进程的结束而结束,所以设置成守护进程就可以了。

6448 生产了 蒸水蛋1
6416 吃 蒸水蛋1
6448 生产了 蒸水蛋2
6796 生产了 清蒸鱼1
6972 生产了 酱油鸡1
6972 生产了 酱油鸡2
6448 生产了 蒸水蛋3
6680 吃 蒸水蛋2
6416 吃 清蒸鱼1
6972 生产了 酱油鸡3
6448 生产了 蒸水蛋4
6796 生产了 清蒸鱼2
6972 生产了 酱油鸡4
6680 吃 酱油鸡1
6416 吃 酱油鸡2
6448 生产了 蒸水蛋5
6796 生产了 清蒸鱼3
6972 生产了 酱油鸡5
6680 吃 蒸水蛋3
6416 吃 酱油鸡3
6796 生产了 清蒸鱼4
6796 生产了 清蒸鱼5
6680 吃 蒸水蛋4
6416 吃 清蒸鱼2
6416 吃 蒸水蛋5
6680 吃 酱油鸡4
6416 吃 清蒸鱼3
6680 吃 酱油鸡5
6416 吃 清蒸鱼4
6680 吃 清蒸鱼5
主进程结束

管道 PIPE
创建管道的类：
Pipe([duplex]):在进程之间创建一条管道，并返回元组（conn1,conn2）,
其中conn1，conn2表示管道两端的连接对象，强调一点：必须在产生Process对象之前产生管道。

参数介绍：
dumplex:默认管道是全双工的，如果将duplex设成False，conn1只能用于接收，conn2只能用于发送。

主要方法：
conn1.recv():接收conn2.send(obj)发送的对象。
如果没有消息可接收，recv方法会一直阻塞。如果连接的另外一端已经关闭，那么recv方法会抛出EOFError。
conn1.send(obj):通过连接发送对象。obj是与序列化兼容的任意对象。

其他方法：
conn1.close():关闭连接。如果conn1被垃圾回收，将自动调用此方法。
conn1.fileno():返回连接使用的整数文件描述符。
conn1.poll([timeout]):如果连接上的数据可用，返回True。timeout指定等待的最长时限。
如果省略此参数，方法将立即返回结果。如果将timeout射成None，操作将无限期地等待数据到达。

conn1.recv_bytes([maxlength]):接收c.send_bytes()方法发送的一条完整的字节消息。
maxlength指定要接收的最大字节数。
如果进入的消息，超过了这个最大值，将引发IOError异常，并且在连接上无法进行进一步读取。
如果连接的另外一端已经关闭，再也不存在任何数据，将引发EOFError异常。

conn.send_bytes(buffer [, offset [, size]])：
通过连接发送字节数据缓冲区，buffer是支持缓冲区接口的任意对象，offset是缓冲区中的字节偏移量，
而size是要发送字节数。
结果数据以单条消息的形式发出，然后调用c.recv_bytes()函数进行接收。   

conn1.recv_bytes_into(buffer [, offset]):接收一条完整的字节消息，并把它保存在buffer对象中，
该对象支持可写入的缓冲区接口（即bytearray对象或类似的对象）。
offset指定缓冲区中放置消息处的字节位移。
返回值是收到的字节数。如果消息长度大于可用的缓冲区空间，将引发BufferTooShort异常。

例：
#!/usr/bin/env python
# _*_ coding: utf-8 _*_

from multiprocessing import Process, Pipe

def f(conn):
    # 管道右端发送消息
    conn.send("Hello The_Third_Wave")
    conn.close()

if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    # 管道另一端接收消息
    print(parent_conn.recv())
    p.join()

注意管道端点的正确管理问题。
如果是生产者或消费者中都没有使用管道的某个端点，就应将它关闭。
这也说明了为何在生产者中关闭了管道的输出端，在消费者中关闭管道的输入端。
如果忘记执行这些步骤，程序可能在消费者中的recv（）操作上挂起。
管道是由操作系统进行引用计数的，必须在所有进程中关闭管道后才能生成EOFError异常。
因此，在生产者中关闭管道不会有任何效果，除非消费者也关闭了相同的管道端点。 

例：
from multiprocessing import Process, Pipe

def f(parent_conn,child_conn):
    parent_conn.close() #不写close将不会引发EOFError，而将此句注释则能正常运行
    while True:
        try:
            print(child_conn.recv())
        except EOFError:
            child_conn.close()

if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(parent_conn, child_conn,))
    p.start()
    child_conn.close()
    parent_conn.send('hello')
    parent_conn.close()
    p.join()

OSError: handle is closed

另外，多个进程之间使用管道竞争之间会引起数据不安全，而为此，管道+锁就会变成队列的实现。

end