多进程

进程简而言之就是一堆指令的集合，进程最终也要通过线程执行，每个进程最低有一个线程

出于安全考虑，进程间是不允许通讯的，

如果要实现python进程间的通讯，Pyhon3提供了中间件进行数据的交互

queue，pipe，manager都可以实现进程间的数据交互，但是也并非真正意义上的数据共享，只是copy了一份数据给对方

在一个进程里开启多个线程：

import multiprocessing, time, threading

def thread_run():
    print(threading.get_ident())

def run(name):
    time.sleep(2)
    print("hello,", name)
    t = threading.Thread(target=thread_run,)
    t.start()


if __name__ == "__main__":
    for i in range(10):
        p = multiprocessing.Process(target=run, args=("Eric %s" % i, ))
        p.start()

　　进程queue:

from multiprocessing import Process, Queue
"""
进程间的通讯
利用queue中间件进行
进程间通讯并非严格意义上的数据完全相通
而是在进程间克隆一份
"""


def put_q(q):
    q.put("from child process")

def get_q(q):
    print(q.get())

if __name__ == "__main__":
    q = Queue()
    #主进程中放入数据
    q.put("from main process")
    #子进程获取并打印数据
    p = Process(target=get_q, args=(q, ))
    #子进程放入数据
    p1 = Process(target=put_q, args=(q, ))
    p.start()
    p1.start()
    #主进程获取并打印数据
    print(q.get())

　　pipe和socket的方式类似:

from multiprocessing import Process, Pipe


def run(conn):
    #接收管道a端发送的数据
    print(conn.recv())
    #从子进程的管道端发送数据
    conn.send("from child process")
    conn.close()


if __name__ == '__main__':
    #创建管道的两端
    a_conn, b_conn = Pipe()
    #顺着管道的a端发送数据
    a_conn.send("from main process")
    #创建子进程，把管道的b端传进去
    p = Process(target=run, args=(b_conn, ))
    #启动进程
    p.start()
    #接受b端发送的数据
    print(a_conn.recv())
    p.join

　　manager:

from multiprocessing import Process, Manager
import os

def run(dict, list):
    #每个进程往字典中存入数据
    dict[os.getpid()] = "dict" + str(os.getpid())
    
    #每个进程往列表中存入数据
    list.append(os.getpid())
    print(list)



if __name__ == '__main__':
    #定义空列表用来存储所有进程对象
    p_list = []
    # manager = Manager()
    with Manager() as manager:
        #创建共享字典
        d = manager.dict()
        #创建共享列表
        l = manager.list()
        #创建10个进程
        for i in range(10):
            p = Process(target=run, args=(d, l, ))
            p.start()
            p_list.append(p)
        for i in p_list:
            i.join()

        #打印最终的字典和列表
        print(d)
        print(l)

　　进程池pool，限制最大的进程数:

from multiprocessing import Process, Pool
import os, time
"""
限制同一时间运行的进程数
"""



#子进程调用函数
def foo(n):
    time.sleep(2)
    print("in process:", os.getpid())
    return n + 100

#主进程回调函数
def bar(arg):
    print("bar process:", os.getpid())
    print("-->exec done:", arg)



if __name__ == '__main__':
    #创建进程池
    pool = Pool(2)
    #打印主进程的id
    print("main process:", os.getpid())
    #创建10个进程
    for i in range(10):
        #串行进程池
        #pool.apply(func=foo, args=(i, ))
        
        #并行进程池
        pool.apply_async(func=foo, args=(i, ), callback=bar)
    print("---endline---")
    #下面两句必须，且顺序不能变
    pool.close()
    pool.join()

　　进程锁，所有进程都会共享屏幕，防止屏幕显示错乱：

from multiprocessing import Process, Lock
"""
进程锁的作用是锁屏，
防止多进程间显示错乱
"""


def run(n):
    lock.acquire()
    print("--start--")
    print("task ", n)
    print("--end--\n\n")
    lock.release()


if __name__ == '__main__':
    #创建锁
    lock = Lock()
    #创建存储进程对象的列表
    p_list = []
    #创建10个进程
    for i in range(100):
        p = Process(target=run, args=(i, ))
        p.start()
        p_list.append(p)
    for i in p_list:
        i.join()