python--多进程

#开进程的方法一:
# import time
# import random
# from multiprocessing import Process
# def piao(name):
#     print('%s piaoing' %name)
#     time.sleep(random.randrange(1,5))
#     print('%s piao end' %name)
#
#
# if __name__=="__main__":
#     p1=Process(target=piao,args=('egon',)) #必须加,号
#     p2=Process(target=piao,args=('alex',))
#     p3=Process(target=piao,args=('wupeqi',))
#     p4=Process(target=piao,args=('yuanhao',))
#
#     p1.start()
#     p2.start()
#     p3.start()
#     p4.start()
#     print('主线程')



#开进程的方法二:
import time
import random
from multiprocessing import Process


class Piao(Process):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        print('%s piaoing' %self.name)

        time.sleep(random.randrange(1,5))
        print('%s piao end' %self.name)

if __name__=='__main__':

    p1=Piao('egon')
    p2=Piao('alex')
    p3=Piao('wupeiqi')
    p4=Piao('yuanhao')

    p1.start() #start会自动调用run
    p2.start()
    p3.start()
    p4.start()
    print('主线程')


进程的join方法

# import time
# from multiprocessing import Process
#
#
# def f(name):
#     time.sleep(1)
#     print("hello",name,time.ctime())
#
#
#
# if __name__=="__main__":
#     p_list=[]
#     for i in range(3):
#         p=Process(target=f,args=("alex",))
#         p_list.append(p)
#         p.start()
#
#     for l in p_list:
#         l.join()
#
#     print("end")


# from multiprocessing import Process
# import time
#
# class MyProcess(Process):
#     def __init__(self):
#         super().__init__()
#
#
#     def run(self):
#         time.sleep(1)
#         print("hello ",self.name,time.ctime())
#
#
# if __name__=="__main__":
#     p_list=[]
#     for i in range(3):
#         p=MyProcess()
#         p.daemon=True#daemon守护进程 跟join效果相反
#         p.start()
#         p_list.append(p)
#
#     # for l in p_list:
#     #     l.join()
#
#     print("end")



# import time,os
# from  multiprocessing import Process
#
# def info(title):
#     print("title: ",title)
#     print("parent process: ",os.getppid())# 父进程pid
#     print("process id ",os.getpid())#pid 进程号
#
# def f(name):
#     info("function f")
#     print("hello",name)
#
#
# if __name__=="__main__":
#
#     info("main process line")
#     time.sleep(1)
#     print("-----------------------------")
#     p=Process(target=info,args=("yuan",))
#     p.start()
#     p.join()

　　

#进程池

from multiprocessing import Process,Pool
import time,os

def foo(i):
    time.sleep(1)
    print(i)
    print("son",os.getpid())
    return i+100


def bar(arg):

    print(os.getpid())
    # print(os.getppid())
    print('logger',arg)


if __name__=="__main__":

    pool=Pool(5)#进程池对象 如果不设置进程池的个数,默认以cpu核心数来运行
    print("main",os.getpid())
    # bar(1)
    # print("---------------")

    for i in range(10):
        pool.apply(func=foo,args=(i,))#同步接口

        #回调函数: 某个函数执行成功之后在去执行的函数
        #func=foo,args=(i,)------>返回值作为 callback 回调函数的参数
        #pool.apply_async(func=foo,args=(i,),callback=bar)#callback=bar回调函数 异步接口
        # 此处的回调函数是在主进程里面执行的


    pool.close()
    pool.join() #join与close调用顺序是固定的
    print("ending")

#进程队列
#队列:线程同步安全使用
# import multiprocessing
# import queue,time
#
# def foo(q):
#     print("son process",id(q))
#     time.sleep(1)
#     q.put(123)
#     q.put("alex")
#
#
# #进程之间的数据是独立的,独占一块内存,通信是数据之间的拷贝比较麻烦
#
# if __name__=="__main__":
#
#     #q = queue.Queue()线程队列
#
#
#     q=multiprocessing.Queue()#进程队列
#     p=multiprocessing.Process(target=foo,args=(q,))
#
#     p.start()
#     print("main process ",id(q))
#     p.join()
#     print(q.get())
#     print(q.get())



#进程之间管道通信
from multiprocessing import Process,Pipe
# def f(conn):
#     conn.send([12,{"name":"yuan"},"hello"])
#     response=conn.recv()
#     print("response",response)
#     conn.close()
#     print("q_ID2",id(conn))
#
#
# if __name__=='__main__':
#
#     parent_conn,child_conn=Pipe()#双向管道
#     print("q_ID1:",id(child_conn))
#     p=Process(target=f,args=(child_conn,))
#     p.start()
#     print(parent_conn.recv())
#     parent_conn.send("儿子你好")
#     p.join()



#Queue和Pipe只是实现了数据交互,并没有实现数据共享,即一个进程去更改另一个进程的数据

#进程共享数据

from multiprocessing import Manager


def f(d,l,n):
    d[n]=1
    d["xzxx"]=900
    l.append(n)


if __name__=="__main__":

    with Manager() as manager:#Manager进程共享对象
        d=manager.dict()

        l=manager.list(range(5))

        p_list=[]

        for i in range(10):
            p=Process(target=f,args=(d,l,i))
            p.start()
            p_list.append(p)

        for res in p_list:
            res.join()


        print(d)
        print(l)

总结：进程理解：由于线程的多线程并不是正真意义上的多线程（因为GIL全局锁的原因），但是python可以实现多进程的并行，同时调用多个核心数，进程之间的内存是互相隔离的，但是他们的一些资源确实共享的，如打印服务等。。进程比较消耗系统资源，但是可以使用多进程+多协程的方式进行任务处理