二十.Python进程

Python进程

#multiProcessing模块

#进程
import  multiprocessing
import time
import os
#multiprocessing  进程模块
#优势：支持多核并行，解决了GIL不能多核并行的问题
#劣势：multiprocessing相对于线程而言，占用的内存较多，影响了服务器的运行性能

#pro=multiprocessing.Process(target,args)创建进程
#pro.start() 开启进程等待cpu运行

#os.getppid() 获取当前进程的父进程id
#os.getpid()  获取当前进程的id

def add():
    #打印add方法进程的父进程id
    print("add 父进程id", os.getppid())
    #打印add方法当前进程的id
    print("add 当前进程id", os.getpid())

if __name__=="__main__":
    #创建add方法的进程
    pro=multiprocessing.Process(target=add)
    #打印当前进程的父进程id
    print("父进程id",os.getppid())
    #打印当前进程id
    print("当前进程id",os.getpid())
    #开启add方法的进程
    pro.start()

 #进程通信

#队列

#进程通信的三种方式
#进程队列通信     通过先进先出的队列实现进程间的存取值的操作
#进程管道通信     通过进程之间建立管道实现进程之间的信息交流
#Manage通信       通过Manage的方式实现进程间值得存取与变更操作

#进程队列
#使用方法相当于线程队列，进程队列可以实现在进程间的相互通信

#使用方法
#que=Queue()  创建队列
#pro=Process(target,(que,)) 创建进程，往参数元组添加队列对象
#pro.start()                开启进程
#que.put()    往队列放值
#que.get()   依此取出队列的值

#导入multiProcessing模块下的Process函数与Queue函数
from multiprocessing import Process,Queue
def show():
    print("ok")
def add(que):
    print("队列存值...")
    que.put(1)
    que.put("111")
    que.put(show)
def getCon(que):
    print("队列取值...")
    print(que.get())
    print(que.get())
    que.get()()
if __name__ == '__main__':
    #创建队列
    que=Queue()
    #创建进程，参数是队列pro
    pro=Process(target=add,args=(que,))
    # 创建进程，参数是队列pro
    pro1=Process(target=getCon,args=(que,))
    #开启进程，进行队列存值操作
    pro.start()
    #阻塞主进程执行
    pro.join()
    #开启进程，取出队列中的值
    pro1.start()

 #Pipo管道

#进程管道通信

# parent,child=Pipe()  创建管道,产生管道的父端和子端，利用父端和子端进行交流
#pro=Process(target,args=(parent,))  创建一个进程，将父子的一端传递给创建的进程
#pro.start()            开启进程
#parent.send(souce)    父端发送信息
#child.recv()           子端接收信息

#从multiProcessing模块导入Process和Pipe函数
from multiprocessing import Process,Pipe

def info():
    print("执行了info方法....")
    print("进程信息")

def add(parent):
    print("通过管道发送信息...")
    #向管道的另一端发送信息
    parent.send([info,"1111"])
def show(child):
    print("通过管道接收信息...")
    #接收管道另一端的信息，没有收到信息会进行阻塞
    a=child.recv()
    #执行info函数
    a[0]()
    print(a[1])
if __name__ == '__main__':
    #创建管道，接收父端和子端
    parent,child=Pipe()
    #创建进程，将父端交给此进程
    pro=Process(target=add,args=(parent,))
    #创建进程，将子端交给此进程
    pro1=Process(target=show,args=(child,))
    #开启进程
    pro.start()
    pro1.start()

 #managers

#managers 用于进程之间的相互通信，进程之间可以相互修改信息

#支持的类型
#list,dict,Namespace,Lock,RLock,Semaphore,BoundedSemaphore,Condition,Event,Queue,Value和Array。

#使用
#manager=Manager()              创建manager
#li=manager.list()              创建线程间可以通信的列表
#pro=Process(target,args=(li,)) 将li当作参数加入到函数进程中
#pro.start()                    启动进程
#pro.join()                     防止manager多进程通信报错
#li.append(souce)               往进程列表添加信息
#print(li)                      在主进程读取信息

#pro.start()之后必须要加上pro.join()，否则会报错

#导入Process,Manager函数
from multiprocessing import Process,Manager

def add(li1):
    #往进程列表加入值
    li1.append(len(li1)+1)
    li1.append(len(li1)+1)
#创建存储进程的list
thread_list=[]
if __name__ == '__main__':
    # manage=Manager()
    # li=manage.list()
    # pro=Process(target=add,args=(li,))
    # pro.start()
    # pro.join()
    # print(li)
    #通过with 生成Manager()  作为manage
    with Manager() as manage:
        #通过manage.list()生成list列表
        mli=manage.list()
        #循环创建进程
        for i in range(20):
            #创建带有进程列表的进程
            pro=Process(target=add,args=(mli,))
            #将创建好的进程加入到list列表
            thread_list.append(pro)
        #循环进程列表
        for i in thread_list:
            #开启进程，等待cpu调用
            i.start()
            #执行join()方法,维持进程安全
            i.join()
        #打印进程列表里的值
        print(mli)





# from multiprocessing import Process,Manager
# import os
# # 这里实现的就是多个进程之间共享内存，并修改数据
# # 这里不需要加锁，因为manager已经默认给你加锁了
#
# def f(d,l):
#     d[1] = '1'
#     d['2'] = 2
#     d[0.25] = None
#     l.append(os.getpid())
#     print(l)
#
# if __name__ == '__main__':
#     with Manager() as manager:
#         d = manager.dict()  #生成一个字典
#         l = manager.list(range(5))  #生成一个列表
#         p_list = []
#         for i in range(10):
#             p = Process(target=f,args=(d,l))
#             p.start()
#             p_list.append(p)
#         for res in p_list:
#             res.join()
#         print(d)
#         print(l)

#进程池

#进程池     指创建多个进程放入一个容器里，等待程序的调用，程序执行完毕，会自动返回

#导入Process和Pool函数，Pool用于生成进城池

#使用
#poo=Pool(process=5) 进程池创建5个进程
#poo.apply_async(func,args,callback)  创建一个进程池任务，如果有多个任务，进城池可以通过任务数量决定是否调用最大的进程数量来完成任务
#poo.close() 关闭进城池
#pool.join() 进城池调用join()方法阻塞主程序的运行

#导入Process和Pool函数
from multiprocessing import Process,Pool
import time
def add(a):
    time.sleep(3)
    print(a)
def back(a):
    print("%s back"%a)

thread_list=[]
if __name__ == '__main__':
    #创建进城池
    pool=Pool(processes=5)
    #循环创建进城池任务
    for i in range(100):
        #创建进程池任务
        po=pool.apply_async(func=add,args=(i,),callback=back)
    #关闭进程池
    pool.close()
    #主程序等待进程池的结束
    pool.join()