python并发编程(管道,事件,信号量,进程池)

from multiprocessing import Process,Pipe

def f1(conn):

    from_zhujincheng = conn.recv()
    print('子进程')
    print('来自主进程的消息:',from_zhujincheng)

if __name__ == '__main__':
    conn1,conn2 = Pipe()  #创建一个管道对象,全双工,返回管道的两端,但是一端发送的消息,只能另外一端接收,自己这一端是不能接收的
    p1 = Process(target=f1,args=(conn2,))
    p1.start()

    conn1.send('出来吧')
    print('主进程')

from multiprocessing import Process,Event

e = Event()  #创建事件对象,这个对象的初识状态为False
print('e的状态是:',e.is_set())  #  False

print('进程运行到这里了')
e.set()  #将e的状态改为True
print('e的状态是:',e.is_set())  #  True

e.clear()  #将e的状态改为False

e.wait()  #e这个事件对象如果值为False,就在我加wait的地方等待

print('进程过了wait')

import time,random
from multiprocessing import Process,Semaphore

def f1(i,s):
    s.acquire()
    print('%s男嘉宾到了'%i)
    time.sleep(random.randint(1,3))
    s.release()

if __name__ == '__main__':
    s = Semaphore(4)  #计数器4,acquire一次减一,为0 ,其他人等待,release加1
    for i in range(10):
        p = Process(target=f1,args=(i,s))
        p.start()

import time
from multiprocessing import Process,Pool

#对比多进程和进程池的效率
def f1(n):
    for i in range(5):
        n = n + i

if __name__ == '__main__':

    #统计进程池执行100个任务的时间
    s_time = time.time()
    pool = Pool(4)  
    pool.map(f1,range(100))  
    e_time = time.time()
    dif_time = e_time - s_time

    #统计100个进程,来执行100个任务的执行时间
    p_s_t = time.time() #多进程起始时间
    p_list = []
    for i in range(100):
        p = Process(target=f1,args=(i,))
        p.start()
        p_list.append(p)
    [pp.join() for pp in p_list]
    p_e_t = time.time()
    p_dif_t = p_e_t - p_s_t
    print('进程池的时间:',dif_time)
    print('多进程的执行时间:',p_dif_t)
    # 结果:  进程池的时间: 0.40102291107177734    多进程的执行时间: 9.247529029846191     
    # 可以看出进程池运行效率远远大于创建多进程

import time
from multiprocessing import Process,Pool

def f1(n):
    time.sleep(1)
    return n*n

if __name__ == '__main__':

    pool = Pool(4)
    for i in range(10):
        res = pool.apply(f1,args=(i,))
        print(res)

import time
from multiprocessing import Process,Pool

def f1(n):
    time.sleep(0.5)
    return n*n

if __name__ == '__main__':

    pool = Pool(4)

    res_list = []
    for i in range(10):
        res = pool.apply_async(f1,args=(i,)) # 不能直接打印返回值,因为直接返回结果对象,进程还没执行完,结果对象里没有数据
        res_list.append(res)

    pool.close()  
    pool.join()

    #打印结果,异步提交之后的结果对象
    for i in res_list:
        print(i.get())

import os
from multiprocessing import Pool,Process

def f1(n):
    print('传入的函数',n)
    return n*n

def call_back_func(asdf):
    print('回调函数',asdf)

if __name__ == '__main__':
    pool = Pool(4)
    res = pool.apply_async(f1,args=(5,),callback=call_back_func)
    pool.close()
    pool.join()