创建多进程

多进程实现并发，全部CPU同时工作

多线程实现假并发，只有一个CPU工作，因为速度太快，先后顺序无法分辨

直接调用

from multiprocessing import Process
import time

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=('alvin',))  # 创建进程对象
        p_list.append(p)
        p.start()
    for p in p_list:
        p.join()
        
    print('end')

类式调用

from multiprocessing import Process
import time

class MyProcess(Process):
    def __init__(self):  # 1.1更换进程名需要在self后加一个参数name
        super(MyProcess, self).__init__()
        #self.name = name # 1.2name重新赋值

    def run(self):
        time.sleep(1)
        print ('hello', self.name,time.ctime())


if __name__ == '__main__':
    p_list=[]
    for i in range(3):
        p = MyProcess()  # 1.3创建进程对象中里面需要加参数，例如chung，三个进程的名字都是chung，如果是每个进程有自己单独的名字，需要分开创建
        p.start()
        p_list.append(p)

    for p in p_list:
        p.join()

    print('end')

进程关系

父进程与子进程之间的关系

from multiprocessing import Process
import os
import time

# 主进程 -----------------------
def info(title):
    print(title)
    print('module name:', __name__)  # __name__是__main__，打印__main__
    print('parent process:', os.getppid())  # 父进程号，用pycharm时，父进程是pycharm。每一个进程都有一个父进程
    print('process id:', os.getpid())  # 本进程号


def f(name):
    info('33[31;1mfunction f33[0m')
    print('hello', name)
    
# 子进程 -----------------------
if __name__ == '__main__':  # Windows必须加，linux不用加
    info('33[32;1mmain process line33[0m')
    time.sleep(3)
    p = Process(target=info, args=('bob',))
    p.start()
    p.join()

Process类

构造方法

Process([group [, target [, name [, args [, kwargs]]]]])

group: 线程组，目前还没有实现，库引用中提示必须是None
target: 要执行的方法
name: 进程名
args/kwargs: 要传入方法的参数

实例方法

is_alive()：返回进程是否在运行
join([timeout])：阻塞当前上下文环境的进程，直到调用此方法的进程终止或到达指定的timeout（可选参数）
start()：进程准备就绪，等待CPU调度
run()：strat()调用run方法，如果实例进程时未制定传入target，这star执行t默认run()方法
terminate()：不管任务是否完成，立即停止工作进程

属性

authkey
daemon：和线程的setDeamon功能一样
exitcode(进程在运行时为None、如果为–N，表示被信号N结束）
name：进程名字
pid：进程号

import time
from  multiprocessing import Process

def foo(i):
    time.sleep(1)
    print (p.is_alive(),i,p.pid)
    time.sleep(1)

if __name__ == '__main__':
    p_list=[]
    for i in range(10):
        p = Process(target=foo, args=(i,))
        #p.daemon=True
        p_list.append(p)

    for p in p_list:
        p.start()
    # for p in p_list:
    #     p.join()

    print('main process end')

进程队列

Queues（重要）

主进程与子进程进行通信

进程间的数据不能共享，是完全独立的

from multiprocessing import Process, Queue

def f(q,n):
    q.put([42, n, 'hello'])

if __name__ == '__main__':
    q = Queue()  # 创建进程队列
    p_list=[]
    for i in range(3):
        p = Process(target=f, args=(q,i))  # 将q作为参数传入
        p_list.append(p)
        p.start()
    print(q.get())
    print(q.get())
    print(q.get())
    for i in p_list:
            i.join()

Pipes（不常用）

主进程与子进程进行通信

from multiprocessing import Process, Pipe
 
def f(conn):
    conn.send([42, None, 'hello'])  # 可以传字符，socket传字节
    conn.close()
 
if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    print(parent_conn.recv())   # prints "[42, None, 'hello']"
    p.join()

Managers

数据共享

from multiprocessing import Process, Manager

def f(d, l, n):
    d[n] = '1'  # d指字典，manager创建的，可以在进程中实现共享
    d['2'] = 2
    d[0.25] = None
    l.append(n)  # n指0-9
    print(l)

if __name__ == '__main__':
    with Manager() as manager:  # with open() as f 等于 f=open()，所以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)