一、管道---Pipe

这是一个单向流动的管道，一次产生一对。看代码：

from multiprocessing import Pipe,Process
def f(c):
    print(c.recv())#接收不需要表明个数
if __name__ == '__main__':
    conn1, conn2 = Pipe()#一次产生两个通道
    p = Process(target=f, args=(conn2,))
    p.start()
    conn1.send('哈哈哈哈哈akfnaslknf')#发送不需要使用字节流

看看源码：
def Pipe(duplex=True):#duplex：有两部分的
    return Connection(), Connection()#这里返回了两个

　　

二、事件--Event

def f(e):
    print('hello,Python!!')
    e.set()#把状态修改为True,如果不修改，程序会停不下来
if __name__ == '__main__':
    ev = Event()#初始状态是False
    print(ev.is_set())#查看事件当前的状态
    p = Process(target=f, args=(ev,))
    p.start()
    # ev.clear()#设置事件状态为False

　　

三、信号量---Semaphore

先看代码吧：

import random

From fultiprocessing import Process,Semaphore
def f(s):
    s.acquire()#这里会-1
    # time.sleep(2)#（1）
    time.sleep(random.randint(1, 5))#（2）
    print('hello')
    s.release()#这里会+1

if __name__ == '__main__':
    s = Semaphore(4)#设置一个数量
    for i in range(10):
        p = Process(target=f, args=(s,))
        p.start()

说明一下：信号量就像是创建了4个通道，进去一个进程会把们锁上，别人来了没有钥匙进不去，只有等某个进程完成了，其他的进程才可以进来。

所以，使用（1）处的方式打印出来时，就是四个一组的被打印出来，而使用（2）处的方式打印时，就有点随机了。这是因为，每次随机出来的时间不一样，所以等待的时间也不一样，某个进程完成后其他的就可以抢夺这个通道。

 

四、进程池---Pool

  1. map（）

 

 def f(n):
    time.sleep(1)
    print(n)
if __name__ == '__main__':
    po = Pool(4)
    po.map(f, range(10))#使用方式类似前面的方式，第一个参数是函数名，第二个是可迭代的参数

 

　　

使用线程池，做操作比直接使用进程，要节省时间，看下代码：

# def fn(n):
#     for i in range(5):
#         n += i
#
# if __name__ == '__main__':
#     st = time.time()
#     po = Pool(os.cpu_count())
#     po.map(fn, range(100))
#     et = time.time()
#
#
#     pst = time.time()
#     lst = []
#     for i in range(100):
#         p = Process(target=fn, args=(i,))
#         p.start()
#         lst.append(p)
#     [pro.join() for pro in lst]
#     pet = time.time()
#     print(et - st)
#     print(pet-pst)

　　2.进程池---apply()

def f(n):
    # print(n*n)
    return n*n
if __name__ == '__main__':
    po = Pool(4)
    for i in range(10):
        res = po.apply(f, args=(i,))#还可以接收返回值
        print(res)

　　

这个执行顺序是同步的，那么和下面的代码有什么区别吗？

def f(n):
    pass
for i in range(10):
    p = Process(target=f,args=(i,))
    p.start()

　　

上面两段代码都是串行，但是还是有很大区别的：（1）使用进程池，其实只是创建了4个进程，而且这四个进程是一直被复用的，直到任务完成才销毁，而下面这种却创建了10个进程。（2）

 3.进程池---apply_async()

  看代码：

 

def f(n):
    # print(n)
    time.sleep(1)
    return n**2
if __name__ == '__main__':
    po = Pool(4)
    res_lst = []#收集结果集
    for i in range(10):
        res = po.apply_async(f, args=(i,))#也可以接收返回值,但是接收到的是结果对象，不是直接的值。
        #res.get()#这个get()与队列Queue的get（）类似，不拿到值，誓不罢休，所以就会等着进程处理完返回了值后再继续往下走，
        # 但是这样循环就没有意义了。所以把这个结果集收集起来，然后在统一处理。
        res_lst.append(res)
    #集中处理结果集
    for r in res_lst:
        print(r.get())
    #使用close（）为的是锁住进程池，不让别的程序继续往这个进程池丢任务，这样做完自己的任务后就可以结束了。
    po.close()#锁住进程池
    po.join()#等待所有任务被执行完，不然主进程结束，子进程也跟着结束了

 

　4.进程池---apply_async(),回调函数

看代码：

def f(i):
    return i**2
def callBackFunc(n):
    print(n)
if __name__ == '__main__':
    po = Pool(4)
    for i in range(10):
	#callback=callBackFunc这里就是一个函数名
        po.apply_async(f, args=(i,), callback=callBackFunc)
    po.close()
    po.join()