Python并发编程基础 №④ 管道、数据共享、进程池（原理、效率测试、回调函数）

1、进程间数据传递之管道（Pipe）

conn1, conn2 = Pipe()
conn1.send('hello Pipe')
print(conn2.recv())
conn1.close()
# print(conn2.recv())  # EOFError
conn2.close()

# demo2
def recv(conn):
    while 1:
        re = conn.recv()
        if re:
            print(re)
        else:
            break
    conn.close()

if __name__ == '__main__':
    conn1, conn2 = Pipe()
    Process(target=recv, args=(conn2,)).start()
    for i in range(3):
        conn1.send('hello recv%d'%i )
    conn1.send(None)
    conn1.close()
    conn2.close()

# demo3
def get(conn1, conn2):
    conn1.close()

    while 1:
        try:
            print('========', conn2.recv())
        except EOFError:
            conn2.close()
            break

if __name__ == "__main__":
    conn1, conn2 = Pipe()
    Process(target=get, args=(conn1, conn2)).start()
    conn2.close()
    for i in range(5):
        conn1.send('hello main')
    conn1.close()

2、进程间的数据共享 Manager

from multiprocessing import Manager
from multiprocessing import Process


def add(dic):
    print(dic['count'])  # 子进程中可以使用
    dic['count'] += 1


if __name__ == '__main__':

    manager = Manager()
    dic = manager.dict({'count': 100})  # 主进程定义的dict
    # dic.setdefault('name', 'tom')  # todo 不能如此增加字典中的项

    p_lst = []
    for i in range(10):
        p = Process(target=add, args=(dic, ))
        p.start()
        p_lst.append(p)
    [p.join() for p in p_lst]
    print(dic)
    #  p.join()  # 没有join会报错：FileNotFoundError: [WinError 2] 系统找不到指定的文件。

3、用管道来实现生产者和消费者问题

import time, random
from multiprocessing import Process
from multiprocessing import Pipe


def produce(conn1, conn2):
    conn2.close()
    for i in range(10):
        time.sleep(random.random())
        msg = '\33[32m新闻社刚刚生成了一条消息,编号No：%d\33[0m' % i
        print(msg)
        conn1.send(msg)
    conn1.close()


def consume(conn):
    while 1:
        try:
            print('消费者消费了：', conn.recv())
        except EOFError:
            conn.close()
            break


if __name__ == '__main__':
    conn1, conn2 = Pipe()

    p1 = Process(target=produce, args=(conn1, conn2))
    p1.start()
    conn1.close()

    c = Process(target=consume, args=(conn2,))
    time.sleep(random.randint(1,2))
    c.start()

    conn2.close()

4、进程池

（1）原理

　　为什么会有进程池的概念
　　　　效率
　　　　每开启进程,开启属于这个进程的内存空间
　　寄存器 堆栈 文件
　　进程过多 操作系统的调度

　　进程池
　　python中的 先创建一个属于进程的池子
　　这个池子指定能存放n个进程
　　先将这些进程创建好

（2）demo与进程池效率测试

from multiprocessing import Pool, Process

# demo1:
def func(x):
    time.sleep(random.random())
    print('hello ***')
    print('-'*46)


if __name__ == '__main__':
    pool = Pool(7)  # 此处可不设，设的话就设你的cpu核数加1,即一次起7个进程
    pool.map(func, range(21))

 1 # demo2 map方法
 2 # 与传统的Process比较，Pool明显效率更高！
 3 def func(n):
 4     for i in range(10):
 5         print(n+1)
 6 
 7 def func2(n):
 8     for i in range(10):
 9         print(n+2)
10 
11 if __name__ == '__main__':
12     start = time.time()
13     pool = Pool(7)               # 7个进程
14     pool.map(func, range(100))    # 100个任务
15     #pool.map(func2, [('tom', 1), 'jack'])  # map的传多个参数
16 
17     t1 = time.time() - start  # 耗时 0.26628756523132324
18 
19     start = time.time()
20     p_lst = []
21     for i in range(100):  # 100个任务
22         p = Process(target=func, args=(i,))
23         p_lst.append(p)
24         p.start()
25     for p in p_lst:p.join()
26     t2 = time.time() - start  # 耗时1.8825409412384033
27 
28     print(t1, t2)  # 0.26628756523132324 1.8825409412384033

 

（3） apply 与apply_asyn方法

def show(n):
    print(n*n)

if __name__ == '__main__':
    pool = Pool()
    for i in range(10):
        #pool.apply(show, args=(i,))  # 同步,不需要下面的代码，也会输出结果！
        pool.apply_async(show, args=(i, ))  # 需要下面的代码,才能有输出！
    pool.close()  # 结束进程池接收任务
    pool.join()   # 感知进程池中的任务执行结束

 

（4）进程池的返回值

from multiprocessing import Pool


def func(num):
    return num*num

# demo1 : 使用apply_async，得到返回记过，然后get，就变同步计算了！
if __name__ == '__main__':
    pool = Pool(7)
    for i in range(10):
        res = pool.apply_async(func, args=(i,))
        #print(res)  # <multiprocessing.pool.ApplyResult object at 0x0000022474085E10>
        print(res.get())  # 同步显示


# demo2：解决，异步计算，同步取结果
if __name__ == '__main__':
    pool = Pool(7)
    res_lst = []
    for i in range(10):
        res = pool.apply_async(func, args=(i, ))
        res_lst.append(res)
    print([res.get() for res in res_lst])

# demo3， 用map,异步计算了，然后结果是返回值的列表
    re = pool.map(func, range(10))
    for i in re:print(i)

（5）进程池回调函数

import os
from multiprocessing import Pool

def func(num):
    print('in func:pid=', os.getpid())
    return num*2

def func2(num):
    print('in func2:pid=', os.getpid())
    num*num

if __name__ == '__main__':
    print('main pid=', os.getpid())
    pool = Pool(7)
    res_lst = []
    for i in range(5):
        res = pool.apply_async(func, args=(i, ), callback=func2)  # 所谓回调函数，是用func的结果，
        # 作为func2的参数，# func2是在主进程中运行的！
        res_lst.append(res)
    for res in res_lst:print(res.get())