一. multiprocess模塊

仔細說來，multiprocess不是一個模塊而是python中一個操作、管理進程的包。 之所以叫multi是取自multiple的多功能的意思,在這個包中幾乎包含了和進程有關的所有子模塊。由於提供的子模塊非常多，為了方便大家歸類記憶，我將這部分大致分為四個部分：創建進程部分，進程同步部分，進程池部分，進程之間數據共享。

process模塊介紹

process模塊是一個創建進程的模塊，借助這個模塊，就可以完成進程的創建。

二. 使用process模塊創建進程

1.第一種：

import os
from multiprocessing import
 
 Process
def func(*args):
    print(args)
    print(‘子進程‘,os.getpid())
    print(‘子進程的父進程‘,os.getppid())
if __name__ == ‘__main__‘:
    p = Process(target=func,args=(‘參數1‘,‘參數2‘))
    p.start()
    p.join()    # 感知一個子進程的結束,將異步的程序改為同步
    print(‘主進程‘, os.getpid())
    print(‘主進程的父進程‘, os.getppid())

2. 第二種

import os
from multiprocessing import Process
class MyProcess(Process):
    def __init__(self,args1,args2):
        super().__init__()
        # Process.__init__(self)
        self.args1 = args1
        self.args2 = args2

    def run(self):
        print(111)
        print(self.args1)
        print
 
(self.args2)
        print(self.pid)

if __name__ == ‘__main__‘:
    p = MyProcess(‘參數1‘,‘參數2‘)
    p.start()
    print(os.getpid())

創建多個子進程

import os
from multiprocessing import Process
def func(filename,count):
    with open(filename,‘w‘,encoding=‘utf-8‘) as f:
        f.write(count*10*‘*‘)

if __name__ == ‘__main__‘:
    p_list = []
    for i in range(10):
        p = Process(target=func,args=(‘userinfo%d‘%i,i))
        p_list.append(p)
        p.start()
    [p.join() for p in p_list]
    print([i for i in os.walk(r‘e:\python10\day37‘)])

三. 進程之間的數據隔離問題

import os
import time
from multiprocessing import Process

def func():
    global n
    n = 0
    print(‘pid:%s‘%os.getpid(),n)

if __name__ == ‘__main__‘:
    n = 100
    p= Process(target=func)
    p.start()
    p.join()
    print(n)

四. 守護進程

import os
import time
from multiprocessing import Process

def func():
    while True:
        print(‘子進程開始‘)
        time.sleep(1)
        print(‘***我還在運行‘)

if __name__ == ‘__main__‘:
    p = Process(target=func)
    p.daemon = True
    p.start()
    p1 = Process(target=func)
    p1.start()
    p1.terminate()
    print(p1.is_alive())
    time.sleep(5)
    print(p1.is_alive())

五. 鎖 —— multiprocess.Lock

加鎖可以保證多個進程修改同一塊數據時，同一時間只能有一個任務可以進行修改，即串行的修改，沒錯，速度是慢了，但犧牲了速度卻保證了數據安全。

雖然可以用文件共享數據實現進程間通信，但問題是：

1.效率低（共享數據基於文件，而文件是硬盤上的數據）

2.需要自己加鎖處理

因此我們最好找尋一種解決方案能夠兼顧：

1、效率高（多個進程共享一塊內存的數據）

2、幫我們處理好鎖問題。這就是mutiprocessing模塊為我們提供的基於消息的IPC通信機制：隊列和管道。 隊列和管道都是將數據存放於

內存中 隊列又是基於（管道+鎖）實現的，可以讓我們從復雜的鎖問題中解脫出來， 我們應該盡量避免使用共享數據，盡可能使用消息傳遞

和隊列，避免處理復雜的同步和鎖問題，而且在進程數目增多時，往往可以獲得更好的可獲展性。

import time
import json
from multiprocessing import Process
from multiprocessing import Lock

def show_ticket(i):
    with open(‘ticket‘) as f:
        dic = json.load(f)
        print(‘余票：%s‘%dic[‘ticket‘])

def buy_ticket(i,lock):
    lock.acquire()
    with open(‘ticket‘) as f:
        dic = json.load(f)
        print(‘余票：%s‘ % dic[‘ticket‘])
        time.sleep(0.1)
    if dic[‘ticket‘] > 0:
        dic[‘ticket‘] -= 1
        print(‘\033[32m%s買到票了\033[0m‘%i)
    else:
        print(‘\033[31m%s買到票了\033[0m‘%i)
    time.sleep(0.1)
    with open(‘ticket‘,‘w‘) as f:
        json.dump(dic,f)
    lock.release()

if __name__ == ‘__main__‘:
    for i in range(10):
        p = Process(target=show_ticket,args=(i,))
        p.start()
    lock = Lock()
    for j in range(10):
        p = Process(target=buy_ticket,args=(j,lock))
        p.start()

python並發編程（進程操作）