Python多进程

普通方式开启进程

from multiprocessing import Process
import os
import time

def fun(i):

    time.sleep(3)
    with open('text','r') as f:
        count = int(f.read())
        count -= 1
    with open('text','w') as f:
        f.write(str(count))
    print('这是 %s 个子进程，PID为 %s 父进程PID为 %s count:%s'%(i,os.getpid(),os.getppid(),count))



if __name__ == '__main__':
    p_s = []
    for i in range(5):
        p = Process(target=fun,args=(i,))
        p_s.append(p)

    for p in p_s:
        p.start()

继承的方式开启进程

from multiprocessing import Process
import time
class MyProcess(Process):
    def __init__(self,*args,**kwargs):
        super().__init__(*args,**kwargs)

    def run(self):
        print('开启了一个子进程...')
        self.fun()

    def fun(self):
        time.sleep(3)
        print('子进程运行了')

if __name__ == '__main__':

    p = MyProcess()
    p.start()

锁

from multiprocessing import Process,Value,Lock
def get_num(num,lock):
    for i in range(10):
        lock.acquire()# 获取锁
        num.value -= 1
        lock.release() # 释放锁
        print(num.value)



def put_num(num,lock):
    for i in range(10):
        lock.acquire() # 获取锁
        num.value += 1
        lock.release() # 释放锁

        print(num.value)


if __name__ == '__main__':
    num = Value('i',10) # Value可以在多个进程之间共享数据
    lock = Lock() # 实例化一个锁

    get_p = Process(target=get_num,args=(num,lock))
    get_p.start()
    put_p = Process(target=put_num,args=(num,lock))
    put_p.start()
    get_p.join()
    put_p.join()
    print(num.value)

信号量

from multiprocessing import Semaphore,Process
import time
def fun(num,lock):
    lock.acquire()
    print('%s进来了。。。'%num)
    time.sleep(1)
    lock.release()
    print('%s出来了....'%num)



if __name__ == '__main__':
    lock = Semaphore(5) # 相当于实例化了一个锁，但是锁有五把钥匙
    for i in range(50):
        p = Process(target=fun,args=(i,lock))
        p.start()

from multiprocessing import Event,Process
import time


def signal_lamp(e):
    while True:
        if e.is_set(): # 如果当前事件状态为true那么将，状态改为false阻塞进程，模拟实现红灯亮起状态
            print('红灯凉了..')
            e.clear()# 将event状态改为false
        else:# 如果当前事件状态为false那么将，状态改为true允许进程运行，模拟实现绿灯灯亮起状态
            print('绿灯凉了....')
            e.set()#将event状态改为true
        time.sleep(10)


def Car(i,e):
    e.wait() # 如果e.is_set()为false则阻塞在这一步，否则运行
    print('第%s辆车过去了....'%i)

if __name__ == '__main__':
    # Event几种方法:
    
    # event.isSet()：返回event的状态值；
    
    # event.wait()：
    # 如果
    # event.isSet() == False将阻塞进程；
    # event.isSet() == True 进程正常运行；
    
    # event.set()： 设置event的状态值为True，所有阻塞池的进程激活进入就绪状态， 等待操作系统调度；
    
    # event.clear()：恢复event的状态值为False。
    e = Event()
    sl = Process(target=signal_lamp,args=(e,))
    sl.start()

    for i in range(10):
        p = Process(target=Car,args=(i,e,))
        p.start()

生产者消费者模型Queue

from multiprocessing import Queue,Process

def producer(q):
    for i in range(20):
        q.put('第 %s 个包子' % (i,))


def comsumer(q):
    while True:
        info = q.get()
        if not info:
            break
        print('消费:%s'%(info,))


if __name__ == '__main__':
    q = Queue(20) # 创建一个队列，队列内部实现了锁机制，所以在进程中共享数据是安全的
    p_p = Process(target=producer,args=(q,))
    p_c = Process(target=comsumer,args=(q,))

    p_p.start()
    p_c.start()
    p_p.join() # 等待生产者完成
    q.put(None)# 如果生产者完成了生成，则在队列中存入None如果，消费者读取到None则退出

生产者消费者模型JoinableQueue

from multiprocessing import Process,JoinableQueue

def producer(q):
    for i in range(20):
        q.put('第 %s 个包子' % (i,))
    q.join() # 阻塞，一直阻塞到消费者消费完所有包子（队列中记录了生产的包子个数）

def comsumer(q):
    while True:
        info = q.get()
        print('消费：%s'%(info,))
        q.task_done()# 每消费完一个包子，就会发送一个信号到队列。
        




if __name__ == '__main__':
    q = JoinableQueue(20)

    p_p = Process(target=producer,args=(q,))
    p_c = Process(target=comsumer,args=(q,))

    p_p.start()
    p_c.daemon = True # 将消费者进程设置为守护进程，那么当主进程的代码全部执行完毕，则会退出消费者进程
    p_c.start()
    p_p.join()  # 主进程等待生产者进程完成
    '''
    这段代码的中心思想：
    首先：生产者进程q.join()会等待消费者吃完所有包子之后才会结束
    然后：主进程 p_p.join() 会等待生产者进程结束
    最后:p_c.daemon = True 会等待主进程结束，然后结束
    
    导致的结果：消费者吃完所有包子 -> 生产者进程结束 -> 主进程代码执行完毕 -> 消费者进程(守护进程)结束
    
    '''

管道

from multiprocessing import Process,Pipe

def producer(con):
    con1,con2 = con
    con2.close()
    for i in range(20):
        con1.send('第 %s 个包子' % (i,))


def comsumer(con):
    con1, con2 = con
    con1.close()
    while True:
        try:
            info = con2.recv()
        except EOFError:
            con2.close()
            break

        print('消费:%s'%(info,))

if __name__ == '__main__':
    # 管道内部没有实现锁机制，需要自己实现。所以管道在多进程中共享数据是不安全的
    con1,con2 = Pipe() # 管道的核心，如果是con1发送，那么只能用con2接收
    p_p = Process(target=producer,args=((con1,con2),))

    p_c = Process(target=comsumer,args=((con1,con2),))
    p_p.start()
    p_c.start()
    p_p.join()
    con1.close()

进程池

from multiprocessing import Pool
import os
import time
def fun(num):

    return num + 1

def call_back(num):
    with open('a.txt','a') as f:
        f.write(str(num))
if __name__ == '__main__':
    pool = Pool(os.cpu_count()+1) # os.cpu_count() 可以计算出当前计算机的核数
    # # map方法 用时：0.2000112533569336
    # start = time.time()
    # res = pool.map(fun,range(100)) # pool.map(函数,可迭代对象) 将可迭代对象中的每一个元素传入函数计算，并且将计算结果返回 res得到一个列表
    # pool.close()  # 想要主进程等待进程池中的任务全部完成。首先得关闭进程池，使新任务无法在放入进程池。之后在使用pool.join()来使主进程阻塞等待
    # pool.join()
    # print(res)
    # print(time.time()-start)


    # #apply（同步）方法，跟没开多进程一样，一个一个执行 用时 0.15600895881652832
    # start = time.time()
    # for i in range(100):
    #     res = pool.apply(func=fun,args=(i,)) # pool.apply(func=函数,args=(参数,)) 可以得到函数的返回值
    #     print(res)
    # print(time.time()-start)

    # apply（异步）方法 用时 0.08100461959838867
    # pool.apply(func=函数,args=(参数,),callback=回调函数)
        #   使用 res.get()可以得到函数的返回值。
        #   回调函数接收一个参数，参数就是func的返回值，自动传参。(回调函数由主进程调用)
    
    # #回调函数的练习 
    # start = time.time()
    # res_l = []
    # for i in range(100):
    #     res = pool.apply_async(func=fun,args=(i,),callback=call_back)
    #     res_l.append(res)
    # pool.close()
    # pool.join()
    # print(time.time()-start)