python进程结尾

管道

from multiprocessing import Process,Pipe

def f1(conn):
    from_master_msg = conn.recv()
    print('这是子进程')
    print('来自主进程的消息:',from_master_msg)

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

    # 可以将一端或者两端发送给其他的进程,那么多个进程之间就可以通过这一个管道进行通信了
    p1 = Process(target=f1,args=(conn2,))
    p1.start()

    conn1.send('猜猜我是谁')

    print('我是主进程')

事件

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

print('程序运行到这里了')

# 将e的状态改为True
e.set()
print('e的状态是:',e.is_set())

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

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

print('进程经过了wait')

基于事件的进程通信

import time
from multiprocessing import Process,Event

def f1(e):
    time.sleep(2)
    n = 100
    print('子进程n的值:',n)
    e.set()

if __name__ == '__main__':
    e = Event()

    p = Process(target=f1,args=(e,))
    p.start()

    print('主进程等待')
    e.wait()
    print('结果已经写入文件了,可以拿到这值')
结果
主进程等待
子进程n的值: 100
结果已经写入文件了,可以拿到这值

信号量

import time
import 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)
    for i in range(10):
        p = Process(target=f1,args=(i,s))
        p.start()

进程池map方法
对比多进程和进程池的效率

import time
from multiprocessing import Process,Pool

def f1(n):
    for i in range(5):
        n += i
if __name__ == '__main__':

    #统计进程池执行100个任务的时间
    s_time = time.time()

    #4表示进程池中启动4个进程,如果不传参数,默认开启的融锦城数一般是cpu的个数
    pool = Pool(4)
    
    #参数数据必须是可迭代的,异步提交任务,自带join功能
    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)

测试多进程的时间

import time
from multiprocessing import Process

def f1():
    time.sleep(2)
    print('子进程1号')

def f2():
    time.sleep(3)
    print('字进程2号')

if __name__ == '__main__':

    s = time.time()
    p = Process(target=f1,)
    p2 = Process(target=f2,)
    p.start()
    p2.start()
    p.join()
    p2.join()
    e = time.time()
    print(e - s)
    print('主进程结束')

进程池同步方法

import time
from multiprocessing import Process,Pool
def f1(n):
    time.sleep(1)
    return n

if __name__ == '__main__':
    pool = Pool(4)
    for i in range(10):
        print('123456')
        
        # 进程池的同步方法,将任务变成了串行
        res = pool.apply(f1,args=(i,))
        print(res)

进程池异步方法

import time
from multiprocessing import Process,Pool
def f1(n):
    time.sleep(0.5)
    return n

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

    res_list = []
    for i in range(5):
        print(123456)

        # 异步给进程池提交任务
        res = pool.apply_async(f1,args=(i,))
        res_list.append(res)

    print('等待所有任务执行完')

    # 锁住进程池,不让其他的程序再往这个进程池里面提交任务
    pool.close()
    pool.join()

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

进程池的回调函数

import os
from multiprocessing import Process,Pool

def f1(n):
    print('进程池里的进程id:',os.getpid())
    print(n)
    return n

def call_back_func(a):
    print(os.getpid())
    print('回调函数中的结果',a)

if __name__ == '__main__':
    pool = Pool(4)
    res = pool.apply_async(f1,args=(5,),callback=call_back_func)
    pool.close()
    pool.join()
    # print(res.get())
    print('主进程的id:',os.getpid())
结果
进程池里的进程id: 16632
5
13392
回调函数中的结果 5
主进程的id: 13392