詳解Python中的程式

multiprocessing是python的多程式管理包，和threading.Thread類似。

1、multiprocessing模組

直接從側面用subprocesses替換執行緒使用GIL的方式，由於這一點，multiprocessing模組可以讓程式設計師在給定的機器上充分的利用CPU。在multiprocessing中，透過建立Process物件生成程式，然後呼叫它的start()方法，

from multiprocessing import Process
  
def func(name):
    print('hello', name)
if __name__ == "__main__":
    p = Process(target=func,args=('zhangyanlin',))
    p.start()
    p.join()  # 等待程式執行完畢

在使用併發設計的時候最好儘可能的避免共享資料，尤其是在使用多程式的時候。 如果你真有需要 要共享資料， multiprocessing提供了兩種方式。

（1）multiprocessing，Array,Value

資料可以用Value或Array儲存在一個共享記憶體地圖裡，如下：

from multiprocessing import Array,Value,Process
  
def func(a,b):
    a.value = 3.333333333333333
    for i in range(len(b)):
        b[i] = -b[i]
if __name__ == "__main__":
    num = Value('d',0.0)
    arr = Array('i',range(11))
  
    c = Process(target=func,args=(num,arr))
    d= Process(target=func,args=(num,arr))
    c.start()
    d.start()
    c.join()
    d.join()
  
    print(num.value)
    for i in arr:
        print(i)

輸出

3.1415927
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

建立num和arr時，“d”和“i”引數由Array模組使用的typecodes建立：“d”表示一個雙精度的浮點數，“i”表示一個有符號的整數，這些共享物件將被執行緒安全的處理。

Array(‘i’, range(10))中的‘i’引數：

‘c’: ctypes.c_char　　　　 ‘u’: ctypes.c_wchar　　　　‘b’: ctypes.c_byte　　　　 ‘B’: ctypes.c_ubyte

‘h’: ctypes.c_short　　　  ‘H’: ctypes.c_ushort　　  ‘i’: ctypes.c_int　　　　　 ‘I’: ctypes.c_uint

‘l’: ctypes.c_long,　　　　‘L’: ctypes.c_ulong　　　　‘f’: ctypes.c_float　　　　‘d’: ctypes.c_double

（2）multiprocessing，Manager

由Manager()返回的manager提供list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value and Array型別的支援。

from multiprocessing import Process,Manager
def f(d,l):
    d["name"] = "zhangyanlin"
    d["age"] = 18
    d["Job"] = "pythoner"
    l.reverse()
  
if __name__ == "__main__":
    with Manager() as man:
        d = man.dict()
        l = man.list(range(10))
  
        p = Process(target=f,args=(d,l))
        p.start()
        p.join()
  
        print(d)
        print(l)

輸出

{0.25: None, 1: '1', '2': 2}
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Server process manager比 shared memory 更靈活，因為它可以支援任意的物件型別。另外，一個單獨的manager可以透過程式在網路上不同的計算機之間共享，不過他比shared memory要慢。

2、程式池（Using a pool of workers）

Pool類描述了一個工作程式池，他有幾種不同的方法讓任務解除安裝工作程式。

程式池內部維護一個程式序列，當使用時，則去程式池中獲取一個程式，如果程式池序列中沒有可供使用的進程式，那麼程式就會等待，直到程式池中有可用程式為止。

我們可以用Pool類建立一個程式池， 展開提交的任務給程式池。 例：

#apply
from  multiprocessing import Pool
import time
  
def f1(i):
    time.sleep(0.5)
    print(i)
    return i + 100
  
if __name__ == "__main__":
    pool = Pool(5)
    for i in range(1,31):
        pool.apply(func=f1,args=(i,))
  
#apply_async
def f1(i):
    time.sleep(0.5)
    print(i)
    return i + 100
def f2(arg):
    print(arg)
  
if __name__ == "__main__":
    pool = Pool(5)
    for i in range(1,31):
        pool.apply_async(func=f1,args=(i,),callback=f2)
    pool.close()
    pool.join()

一個程式池物件可以控制工作程式池的哪些工作可以被提交，它支援超時和回撥的非同步結果，有一個類似map的實現。

processes ：使用的工作程式的數量，如果processes是None那麼使用 os.cpu_count()返回的數量。

initializer： 如果initializer是None，那麼每一個工作程式在開始的時候會呼叫initializer(*initargs)。

maxtasksperchild：工作程式退出之前可以完成的任務數，完成後用一個心的工作程式來替代原程式，來讓閒置的資源被釋放。maxtasksperchild預設是None，意味著只要Pool存在工作程式就會一直存活。

context: 用在制定工作程式啟動時的上下文，一般使用 multiprocessing.Pool() 或者一個context物件的Pool()方法來建立一個池，兩種方法都適當的設定了context

注意：Pool物件的方法只可以被建立pool的程式所呼叫。

New in version 3.2: maxtasksperchild

New in version 3.4: context

程式池的方法

apply(func[, args[, kwds]]) ：使用arg和kwds引數呼叫func函式，結果返回前會一直阻塞，由於這個原因，apply_async()更適合併發執行，另外，func函式僅被pool中的一個程式執行。

apply_async(func[, args[, kwds[, callback[, error_callback]]]]) ： apply()方法的一個變體，會返回一個結果物件。如果callback被指定，那麼callback可以接收一個引數然後被呼叫，當結果準備好回撥時會呼叫callback，呼叫失敗時，則用error_callback替換callback。 Callbacks應被立即完成，否則處理結果的執行緒會被阻塞。

close() ： 阻止更多的任務提交到pool，待任務完成後，工作程式會退出。

terminate() ： 不管任務是否完成，立即停止工作程式。在對pool物件程式垃圾回收的時候，會立即呼叫terminate()。

join() : wait工作執行緒的退出，在呼叫join()前，必須呼叫close() or terminate()。這樣是因為被終止的程式需要被父程式呼叫wait（join等價與wait），否則程式會成為殭屍程式。

map(func, iterable[, chunksize])?

map_async(func, iterable[, chunksize[, callback[, error_callback]]])?

imap(func, iterable[, chunksize])?

imap_unordered(func, iterable[, chunksize])

starmap(func, iterable[, chunksize])?

starmap_async(func, iterable[, chunksize[, callback[, error_back]]])。