Python實現多進程的詳解（附範例）

本篇文章帶給大家的內容是關於Python實現多進程的詳解（附範例），有一定的參考價值，有需要的朋友可以參考一下，希望對你有幫助。

fork函數建立子程序

基本上使用

Linux 作業系統提供了一個fork函數用來建立子程序。 fork()位於Python的os模組中。
使用導入os模組即可。

import os
os.fork()

每次呼叫fork()函數後，對應的父行程都會產生一個子程序。
例如下面這段程式碼：

import os
os.fork()
os.fork()
os.fork()

執行之後將會產生8個進程。

fork()函數的回傳值

fork()函數對於子程序的回傳值永遠是0，而對父行程的回傳值則是子程序的pid(進程號​​)。

實例

#!/usr/bin/env python
import os
import time

rt = os.fork()

if rt == 0:
    print(f"The child process is {os.getpid()} . His father is {os.getppid()}")  # os.getpid()获取当前进程进程号，os.getppid()获取当前进程的父进程号
    time.sleep(5)
else:
    print(f"The father process is {os.getpid()} . His father is {os.getppid()}")
    time.sleep(5)

print(f"Now the process is {os.getpid()} . His father is {os.getppid()}")

執行結果：

#程式模組

導入模組

Python也提供了multiprocessing函式庫為全平台提供了多執行緒程式設計。

import multiprocessing

簡單進程

下面程式碼為一個簡單行程：

from multiprocessing import Process


def work(num):
    for i in range(10):
        num += 1
    print(num)
    return 0


def main():
    num = 1
    p1 = Process(target = work, args = (num,))
    p1.start()


if __name__ == '__main__':
    main()

##這裡從multiprocessing庫引入Process這個類別。

p1 = Process(target = work, args = (num,))是建立一個流程。 target為要執行任務的函數，args則為接收的參數，必須以元組形式給與。
start()是讓行程開始運作。
同時進程有一些方法：

join方法

Process的join方法與多執行緒類似。為等待進程運行結束。

使用方法：join(timeout)。
使用join()，程式會等待進程結束後再繼續進行下面的程式碼。
如果加入了timeout參數，則程式會等待timeout秒後繼續執行下面的程式。

close方法

close()用於關閉進程，但是不能關閉正在運行的子進程。

進程類別

可以透過建立類別的方式實現多重進程：

from multiprocessing import Process
import time


class My_Process(Process):

    def __init__(self,num):
        Process.__init__(self)
        self.num = num

    def run(self):
        time.sleep(2)
        print(self.num)


def main():
    for i in range(10):
        p = My_Process(i)
        p.start()


if __name__ == '__main__':
    main()

進程池

from multiprocessing import Pool
import time


def target(num):
    time.sleep(2)
    print(num)


def main():
    pool = Pool(3)
    for i in range(3):
        pool.apply_async(target,(i,))
    pool.close()
    pool.join()
    print('Finish!!!')


if __name__ == '__main__':
    main()

對Pool物件呼叫join()方法會等待所有子程序執行完畢，呼叫join()之前必須先呼叫close()，呼叫close()之後就不能繼續加入新的Process了。

Pool(num)裡的num為要加到裡面的行程數。不指定進程數，則預設為CPU核心數量。

進程間相互獨立

多進程的每一個進程都有一份變數的拷貝，進程之間的操作互不影響。

import multiprocessing
import time

zero = 0

def change_zero():
    global zero
    for i in range(3):
        zero = zero + 1
        print(multiprocessing.current_process().name, zero)

if __name__ == '__main__':
    p1 = multiprocessing.Process(target = change_zero)
    p2 = multiprocessing.Process(target = change_zero)
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print(zero)

最後的執行結果：

#如果進行檔案IO操作，則多進程都會寫入同一個檔案。

佇列

使用multiprocessing裡的Queue可使不同進程存取相同的資源。

from multiprocessing import Process, Queue
def addone(q):
    q.put(1)
def addtwo(q):
    q.put(2)
if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=addone, args = (q, ))
    p2 = Process(target=addtwo, args = (q, ))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print(q.get())
    print(q.get())

以上是Python實現多進程的詳解（附範例）的詳細內容。更多資訊請關注PHP中文網其他相關文章！