管道,信号量,进程池

管道:

　　conn1,conn2 = Pipe()

　　conn1.recv()  # recv() 不需要加内容长度(整数)

　　conn1.send()  # send() 不需要编码

　　数据接收一次就没有了

def chi(n):
    print("我是子进程")
    from_conn1 = n.recv()
    print(from_conn1)

if __name__ == '__main__':
    conn1,conn2 = Pipe()
    p = Process(target=chi,args=(conn2,))
    p.start()
    conn1.send("儿子,干哈呢?")
    print("父进程结束")

　　

 

事件:

　　e = Event()  #初识状态是false

　　e.wait()  当事件对象e的状态为false的时候,在wait的地方会阻塞程序,当对象状态为true的时候,直接在这个wait地方继续往下执行

　　e.set()  将事件对象的状态改为true,

　　e.is_set() 查看状态

　　e.clear()  将事件对象的状态改为false

 

信号量:

　　s = semphore(4),内部维护了一个计数器,acquire-1,release+1,为0的时候,其他的进程都要在acquire之前等待

　　只有这一种方式来锁

　　　　s.acquire()

　　　　需要锁住的代码

　　　　s.release()

 　

import time
from multiprocessing import Process,Semaphore

def func1(n,m):
    n.acquire()
    print(f"{m}号女技师为您服务")
    time.sleep(1)
    n.release()

if __name__ == '__main__':
    s = Semaphore(3)
    for i in range(10):
        p = Process(target=func1,args=(s,i+1,))
        p.start()

　　

进程池: 进程的创建和销毁是很有消耗的,影响代码执行效率

　　map:异步提交任务,并且传参需要可迭代类型的数据,自带close和join功能

　　测试多进程和进程池的效率对比:

import time
from multiprocessing import Process,Pool

def f1(m):
    for i in range(5):
        m += i

if __name__ == '__main__':
    # 进程池设置三个进程
    p1 = Pool(3)
    # 创建进程时得到时间戳
    p1_go_time = time.time()
    # 参数1放进程的逻辑,参数2放可迭代对象.map是异步提交任务,但自带close和join
    p1.map(f1,range(100))
    # 所有进程结束后得到一个时间戳
    p1_end_time = time.time()
    p1_time = p1_end_time - p1_go_time

    p2_lis = []
    # 创建进程时得到时间戳
    p2_go_time = time.time()
    for i in range(100):
        # 创建进程对象,把循环的内容当做参数,传给函数
        p2 = Process(target=f1,args=(i,))
        p2.start()
        # 把进程对象都添加到列表中,方便让对象都join.
        p2_lis.append(p2)

    for i in p2_lis:
        #把每个创建的进程对象都join,进程最慢的执行完之后,继续向下执行
        #假如不加join的话,就是for循环创建完所有进程之后,直接向后执行,而子进程并没有执行完.
        i.join()  
    # 所有多进程结束后得到一个时间戳
    p2_end_time = time.time()
    p2_time = p2_end_time - p2_go_time

    print("进程池耗时:",p1_time)
    print("多进程耗时:", p2_time)

　　

 

　　

　　res = apply( f1,args=(i,) )  #同步执行任务,必须等任务执行结束才能给进程池提交下一个任务,可以直接拿到返回结果res

 

import time
from multiprocessing import Process,Pool

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

if __name__ == '__main__':
    pool = Pool(4)

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

　　

 

　　res_obj = apply_async( f1,args=(i,) )  #异步提交任务,可以直接拿到结果对象,从结果对象里面拿结果,要用get方法,get方法会阻塞程序,没有拿到结果会一直等待

　　close : 锁住进程池,防止有其他的新的任务在提交给进程池

　　join : 等待着进程池将自己里面的任务都执行完

 　  get  :  拿到函数在进程执行的结果,没有拿到结果会一直等待,get方法会阻塞程序

import time
from multiprocessing import Process, Pool

def f1(n):
    time.sleep(2)
    print(n)
    return n * n

if __name__ == '__main__':
    pool = Pool(4)

    res_list = []
    for i in range(10):
        print('xxxx')
        # 异步给进程池提交任务
        res = pool.apply_async(f1, args=(i,))
        res_list.append(res)

    print('等待所有进程执行完')
    pool.close()  #锁住进程池,意思就是不让其他的程序再往这个进程池里面提交任务了
    pool.join()   #等进程执行完之后,才继续向下执行
    print('所有进程执行结束')

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

    print("主程序结束")

　　

　　

回调函数:

 　　apply_async(f1,args=(i,),callback=function)  #将前面f1这个任务的返回结果作为参数传给callback指定的那个function函数

 

转载于:https://www.cnblogs.com/gyc-tzx/p/10251462.html