Python学习——多进程学习

基本的多进程的使用：

from multiprocessing import Process
import threading
import os


def info(title):
    print(title)
    print('module name:', __name__)
    print('parent process:', os.getppid())
    print('process id:', os.getpid())
    print("

")


def f(name):
    info('33[31;1mfunction f33[0m')
    print('hello', name)


if __name__ == '__main__':
    info('33[32;1mmain process line33[0m')
    #p = threading.Thread(target=f, args=('bob',))
    p = Process(target=f, args=('bob',))    #its parent process will be this program ,not pycharm.
    p.start()
    p.join()

不同进程间内存是不共享的，要想实现两个进程间的数据交换，可以用以下方法：

Queue

from multiprocessing import Queue

pickle(序列化，实际是把内存的数据放到硬盘上，所以不同的进程可以都可以访问，当然整个过程进行了包装）

from multiprocessing import Process, Queue
import queue

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


if __name__ == '__main__':
    q = Queue()   #不出现报错的原因在于，pickle模块实现了对数据的封装（复制一个q进入另一个进程，还有其他后续处理）
    #q = queue.Queue()  #会出现报错，因为两个进程之间不同互通数据。
    p = Process(target=f, args=(q,))
    p.start()
    print(q.get())  # prints "[42, None, 'hello']"
    p.join()

Manager

这个是实时共享数据的。

from multiprocessing import Process, Manager
import os

def f(d, l):
    d[1] = os.getpid()  #可以利用这个看出来，这个数据是共享的数据
    d['2'] = 2
    print(d)
    d[0.25] = None
    l.append(os.getpid())

    print(l)

if __name__ == '__main__':
    with Manager() as manager:  #Manager可以建立多种进程共享数据
        d = manager.dict()   #生成字典，可在多个进程间共享和传递
        l = manager.list(range(5))   #生成一个列表，里面预置了0-4,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)

Lock

多线程的Lock，是为了避免屏幕输出或者其他共用输出出现混乱编码的情况。

但是多进程如果是使用manager来做这个管理就会自动加锁，所以不需要自己管理。

进程池

类似于现场的信号量。

必须注意要先close()，再进行join()

pool.close()
pool.join() 

进程池中有两个方法：

• apply
• apply_async  

使用方法：

#pool.apply_async(func=Foo, args=(i,), callback=Bar)   #这个是异步执行，就是并行;callback,回调，就是执行完Foo后，再执行Bar，
#pool.apply(func=Foo, args=(i,))  #这个是同步执行，就是串行

callback:是利用父进程来进行调用，这样可以提高效率，比如执行完进程之后，连接数据库修改日志的时候；

from  multiprocessing import Process, Pool,freeze_support
import time
import os

def Foo(i):
    time.sleep(2)
    print("in process",os.getpid())
    return i + 100

def Bar(arg):
    print('-->exec done:', arg,os.getpid())

if __name__ == '__main__':
    #freeze_support()
    pool = Pool(processes=5) #允许进程池同时放入5个进程
    print("主进程",os.getpid())
    for i in range(10):
        pool.apply_async(func=Foo, args=(i,), callback=Bar) #callback=回调
        #pool.apply(func=Foo, args=(i,)) #串行
        #pool.apply_async(func=Foo, args=(i,)) #串行
    print('end')
    pool.close()
    pool.join() #进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。.join()