快捷導航

Python語法學習之進程的創(chuàng)建與常用方法詳解

更新時間：2022年04月08日 08:29:05 作者：渴望力量的哈士奇

本文我們將學習一下在?Python?中去創(chuàng)建并使用多進程的方法，可以通過創(chuàng)建多個進程來幫助我們提高腳本執(zhí)行的效率，感興趣的可以了解一下

該章節(jié)我們來學習一下在 Python 中去創(chuàng)建并使用多進程的方法，通過學習該章節(jié)，我們將可以通過創(chuàng)建多個進程來幫助我們提高腳本執(zhí)行的效率?？梢哉J為縮短腳本執(zhí)行的時間，就是提高執(zhí)行我們腳本的效率。接下來讓我們都看一下今天的章節(jié)知識點都有哪些？

進程的創(chuàng)建模塊 - multiprocessing

創(chuàng)建進程函數(shù) - Process

函數(shù)名	介紹	參數(shù)	返回值
Process	創(chuàng)建一個進程	target, args	進程對象

Process功能介紹：實例化一個對象；它需要傳入兩個參數(shù) target 與 args：target 是一個函數(shù)，args 是對應(yīng)一個函數(shù)的參數(shù)(args參數(shù)是一個元組)。其實我們可以這樣去理解，在一個腳本中創(chuàng)建子進程，目的是為了讓它執(zhí)行我們腳本中的某個函數(shù)。換句話講，我們將腳本中的某一個函數(shù)單獨的啟用一個進程去執(zhí)行。

我們說過進程之間互不干擾，可以同時執(zhí)行。所以我們可以認為主進程中的程序和子進程的函數(shù)是相互不干擾的，聽起來可能很難理解，一會兒下文我們進行一個案例的小練習，一遍幫助大家去更好的理解其中的含義。

進程的常用方法

函數(shù)名	介紹	參數(shù)	返回值
start	執(zhí)行進程	無	無
join	阻塞進程	無	無
kill	殺死進程	無	無
is_alive	判斷進程是否存活	無	bool

start 函數(shù)：通過調(diào)用它，可以直接啟動我們創(chuàng)建的進程。它會馬上執(zhí)行我們進程中傳入的函數(shù)，start 函數(shù)沒有任何參數(shù)，也沒有返回值。
join 函數(shù)：我們說過，主進程和子進程的程序會同時運行，互不影響。這樣就會有一個問題，有可能是子進程先執(zhí)行完它的業(yè)務(wù)，也有可能是主進程先執(zhí)行完它的業(yè)務(wù)邏輯。如果有的時候我們必須要先執(zhí)行完子進程的業(yè)務(wù) 再執(zhí)行主進程的業(yè)務(wù) 。則通過調(diào)用 join 函數(shù)，在這一函數(shù)下面執(zhí)行的主進程業(yè)務(wù)要等待子進程完成之后才會繼續(xù)執(zhí)行。我們將 join 這樣的函數(shù)叫做等待/阻塞函數(shù)。join 函數(shù)沒有任何參數(shù)，也沒有返回值。
kill 函數(shù)：如果我們在執(zhí)行子進程的過程中發(fā)現(xiàn)不需要這個子進程繼續(xù)運行了，就可以使用 kill 函數(shù)殺死當前的這個子進程，殺死的這個子進程不會在執(zhí)行子進程中函數(shù)的業(yè)務(wù)邏輯。kill 函數(shù)沒有任何參數(shù)，也沒有返回值。
is_alive 函數(shù)：通過調(diào)用這個函數(shù)可以判斷當前的進程是否是存活狀態(tài)，它返回一個 bool 值。True 表示當前進程還在，程序還在繼續(xù)執(zhí)行；如果是 False 則代表當前進程已經(jīng)結(jié)束了

start 函數(shù)

演示案例：

我們先定義兩個簡單的函數(shù)，每個函數(shù)定義兩個簡單的 for 循環(huán)。
每執(zhí)行一次循環(huán)，休眠一秒的時間。
在兩次循環(huán)的開始定義一個實例化時間對象，用以計算兩次循環(huán)的時間間隔。
同時，獲取腳本執(zhí)行的進程號; 看看是一個怎樣的結(jié)果。

# coding:utf-8


import time
import os


def work_for_first():

    for i in range(5):
        print('\'work_for_first\' 函數(shù)的循環(huán)值：%s', '進程號為：%s' % i, os.getpid())	# os.getpid() 為獲取進程號函數(shù)
        time.sleep(1)


def work_for_second():
    for i in range(5):
        print('\'work_for_second\' 函數(shù)的循環(huán)值：%s',  '進程號為：%s' % i, os.getpid())
        time.sleep(1)


if __name__ == '__main__':
    start_time = time.time()    # 獲取執(zhí)行 循環(huán) 之前的時間戳
    work_for_first()
    work_for_second()
    end_time = time.time() - start_time     # 獲取執(zhí)行 循環(huán) 結(jié)束的時間戳
    print('耗時時間為：{}, 進程號為：{}'.format(end_time, os.getpid()))  # 獲取耗時與進程號

執(zhí)行結(jié)果如下圖：

OKK！接下來進入我們今天要學習的主題。

將 work_for_first() 函數(shù)創(chuàng)建一個新的子進程去執(zhí)行。

# coding:utf-8


import time
import os
import multiprocessing


def work_for_first():

    for i in range(5):
        print('\'work_for_first\' 函數(shù)的循環(huán)值：{}，進程號為：{}'.format(i, os.getpid()))
        time.sleep(1)


def work_for_second():
    for i in range(5):
        print('\'work_for_second\' 函數(shù)的循環(huán)值：{}，進程號為：{}'.format(i, os.getpid()))
        time.sleep(1)


if __name__ == '__main__':
    start_time = time.time()    # 獲取執(zhí)行 循環(huán) 之前的時間戳
    work_for_first_process = multiprocessing.Process(target=work_for_first)     # 因為我們傳入的函數(shù)沒有參數(shù)所以 args 可以不寫
    work_for_first_process.start()
    work_for_second()
    end_time = time.time() - start_time     # 獲取執(zhí)行 循環(huán) 結(jié)束的時間戳
    print('耗時時間為：{}, 進程號為：{}'.format(end_time, os.getpid()))  # 獲取耗時與進程號

執(zhí)行結(jié)果如下圖：

因為我們針對 work_for_first() 函數(shù)創(chuàng)建一個新的子進程去執(zhí)行，所以我們的耗時變?yōu)榱?5秒。那么如果我們將 work_for_second() 函數(shù)也創(chuàng)建一個新的子進程去執(zhí)行，耗時又會是多少呢？我們接著往下看。

# coding:utf-8


import time
import os
import multiprocessing


def work_for_first():

    for i in range(5):
        print('\'work_for_first\' 函數(shù)的循環(huán)值：{}，進程號為：{}'.format(i, os.getpid()))
        time.sleep(1)


def work_for_second():
    for i in range(5):
        print('\'work_for_second\' 函數(shù)的循環(huán)值：{}，進程號為：{}'.format(i, os.getpid()))
        time.sleep(1)


if __name__ == '__main__':
    start_time = time.time()    # 獲取執(zhí)行 循環(huán) 之前的時間戳
    work_for_first_process = multiprocessing.Process(target=work_for_first)     # 因為我們傳入的函數(shù)沒有參數(shù)所以 args 可以不寫
    work_for_first_process.start()

    work_for_second_process = multiprocessing.Process(target=work_for_second)
    work_for_second_process.start()
    end_time = time.time() - start_time     # 獲取執(zhí)行 循環(huán) 結(jié)束的時間戳
    print('耗時時間為：{}, 進程號為：{}'.format(end_time, os.getpid()))  # 獲取耗時與進程號

執(zhí)行結(jié)果如下圖：

PS：從腳本中執(zhí)行入口的 main 函數(shù)可以看出 work_for_first() 函數(shù) 與 work_for_second() 函數(shù) 分別都由各自的子進程來執(zhí)行，主進程實際執(zhí)行的只有 23行、29行、30行代碼，所以從耗時來看，主進程實際上只執(zhí)行了 0.026 秒。

這里再思考一個問題，如果是每一個子進程都單獨的通過 .start 去啟動，那么在子進程很多的情況下，啟動的確實會有一些慢了。這個時候我們就可以通過 for 循環(huán)的方式去啟動子進程。方式如下：

    for sun_process in (work_for_first_process, work_for_second_process):
        sun_process.start()

join 函數(shù)

同樣的也會存在著這樣一種情況，我們希望子進程運行結(jié)束之后再去執(zhí)行我們的主進程，這時候我們就會使用到 join 函數(shù) 。

這里我們就利用上文的進程 for循環(huán)同時啟動兩個子進程，然后我們再在下一個 for循環(huán) 執(zhí)行 join 函數(shù)，我們看看會發(fā)生什么。

# coding:utf-8


import time
import os
import multiprocessing


def work_for_first():

    for i in range(5):
        print('\'work_for_first\' 函數(shù)的循環(huán)值：{}，進程號為：{}'.format(i, os.getpid()))
        time.sleep(1)


def work_for_second():
    for i in range(5):
        print('\'work_for_second\' 函數(shù)的循環(huán)值：{}，進程號為：{}'.format(i, os.getpid()))
        time.sleep(1)


if __name__ == '__main__':
    start_time = time.time()    # 獲取執(zhí)行 循環(huán) 之前的時間戳
    work_for_first_process = multiprocessing.Process(target=work_for_first)     # 因為我們傳入的函數(shù)沒有參數(shù)所以 args 可以不寫
    # work_for_first_process.start()

    work_for_second_process = multiprocessing.Process(target=work_for_second)
    # work_for_second_process.start()

    for sun_process in (work_for_first_process, work_for_second_process):
        sun_process.start()

    for sun_process in (work_for_first_process, work_for_second_process):
        sun_process.join()

    end_time = time.time() - start_time     # 獲取執(zhí)行 循環(huán) 結(jié)束的時間戳
    print('耗時時間為：{}, 進程號為：{}'.format(end_time, os.getpid()))  # 獲取耗時與進程號

執(zhí)行結(jié)果如下圖：

kill 函數(shù) 與 is_alive 函數(shù)

接下來我們再嘗試一個場景，利用 for 循環(huán)，我們同時啟動 work_for_first() 函數(shù) 與 work_for_second() 函數(shù) 的子進程。然后我們再在另一個 for 循環(huán)中，將 work_for_second() 函數(shù) 的子進程 kill 掉，然后判斷兩個子進程的存活狀態(tài)。

示例腳本如下：

# coding:utf-8


import time
import os
import multiprocessing


def work_for_first():

    for i in range(5):
        print('\'work_for_first\' 函數(shù)的循環(huán)值：{}，進程號為：{}'.format(i, os.getpid()))
        time.sleep(1)


def work_for_second():
    for i in range(5):
        print('\'work_for_second\' 函數(shù)的循環(huán)值：{}，進程號為：{}'.format(i, os.getpid()))
        time.sleep(1)


if __name__ == '__main__':
    start_time = time.time()    # 獲取執(zhí)行 循環(huán) 之前的時間戳
    work_for_first_process = multiprocessing.Process(target=work_for_first)     # 因為我們傳入的函數(shù)沒有參數(shù)所以 args 可以不寫
    # work_for_first_process.start()

    work_for_second_process = multiprocessing.Process(target=work_for_second)
    # work_for_second_process.start()

    for sun_process in (work_for_first_process, work_for_second_process):
        sun_process.start()
        time.sleep(1)   # 休眠一秒是為了 work_for_second_process 子進程 至少能夠運行一次


    for sun_process in (work_for_first_process, work_for_second_process):
        work_for_second_process.kill()
        if work_for_first_process.is_alive():
            print('\'work_for_first_process\' 子進程當前存活狀態(tài)為：True')
        elif not work_for_second_process.is_alive():
            print('\'work_for_second_process\' 子進程當前存活狀態(tài)為：False')

        sun_process.join()

    end_time = time.time() - start_time     # 獲取執(zhí)行 循環(huán) 結(jié)束的時間戳
    print('耗時時間為：{}, 進程號為：{}'.format(end_time, os.getpid()))  # 獲取耗時與進程號

運行結(jié)果如下：