进程

多进程multiprocessing

　　多线程适合场景：不适合cpu操作密集型的任务，适合io密集型的任务

　　多进程适合场景：适合cpu操作密集型的任务

进程启动方法

from multiprocessing import Process
import time

def f(name):
	time.sleep(2)
	print("hello",name)

if __name__ == "__main__":
	p = Process(target=f,args=("bob",))
	p.start()
	p.join()    # 等待进程执行完成

 获取进程id（每个进程都是由父进程启动的）

from multiprocessing import Process
import os
 
def info(title):
    print(title)
    print('module name:', __name__)
    print('parent process:', os.getppid())  # os.getppid()查父进程pid
    print('process id:', os.getpid())  # os.getpid()查当前进程pid
    print("\n\n")
 
def f(name):
    info('\033[31;1mfunction f\033[0m')
    print('hello', name)
 
if __name__ == '__main__':
    info('\033[32;1mmain process line\033[0m')
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

进程间通讯

　　不同进程间内存是不共享的，要实现两个进程间的数据交换

Queues 队列（父进程与子进程之间队列通信通过pickle序列化与反序列化）

from multiprocessing import Process, Queue
 
def f(q):
    q.put([42, None, 'hello'])  
 
if __name__ == '__main__':
    q = Queue()  # 队列对象
    p = Process(target=f, args=(q,))  # 父进程与子进程其实不是同一个队列，传给子进程时实际上是克隆了一份
    p.start()
    print(q.get())    # prints "[42, None, 'hello']"
    p.join()

Pipes 管道：返回一对连接对象（通过send与recv方式存放、提取数据）

　　　　　　同一时刻有多个进程或线程同时读或者写时数据可能会损坏

from multiprocessing import Process, Pipe
 
def f(conn):
    conn.send([42, None, 'hello'])
    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：Managers()能够让其他进程通过代理来控制它

　　　　　　支持的类型： list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value and Array.

from multiprocessing import Process, Manager
 
def f(d, l):
    d[1] = '1'  # 子进程字典中写入数据
    d['2'] = 2
    d[0.25] = None
    l.append(1)   # 子进程列表中写入数据
    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)   # 主进程读取列表中数据

进程同步

from multiprocessing import Process, Lock


def f(l, i):
    l.acquire()
    try:
        print('hello world', i)
    finally:
        l.release()


if __name__ == '__main__':
    lock = Lock()

    for num in range(10):
        Process(target=f, args=(lock, num)).start()

进程池

　　进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进程，那么进程就会等待，直到进程池中有可用进程池为止

from  multiprocessing import Process,Pool
import time
import os
 
def Foo(i):
    time.sleep(2)
    print("current pid",os.getpid())
    return i+100
 
def Bar(arg):
    print('-->exec done:',arg)
 
pool = Pool(5)  # 允许进程池中同时放入5个进程,其他的都是挂起状态
 
for i in range(10):
    # callback=回调，前面没做完就不执行callback，执行完了就执行callback，回调是父进程调用的
    # 如果子进程回调的话会造成多个连接的情况，父进程每执行完回调性能更好
    pool.apply_async(func=Foo, args=(i,),callback=Bar)   # 异步执行
    #pool.apply(func=Foo, args=(i,))    # 同步执行，相当于串行
 
print('end')
pool.close()
pool.join() # 进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭（apply_async）。