Python進程和線程的概念是什么

這篇文章主要介紹“Python進程和線程的概念是什么”，在日常操作中，相信很多人在Python進程和線程的概念是什么問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Python進程和線程的概念是什么”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

并發編程就是實現讓程序同時執行多個任務，而如何實現并發編程呢，這里就涉及到進程和線程這兩個概念。

對于操作系統來說，一個任務（或者程序）就是一個進程(Process)，比如打開一個瀏覽器是開啟一個瀏覽器進程，打開微信就啟動了一個微信的進程，打開兩個記事本，就啟動兩個記事本進程。

進程的特點有：

• 操作系統以進程為單位分配存儲空間， 每個進程有自己的地址空間、數據棧以及其他用于跟蹤進程執行的輔助數據；

• 進程可以通過 fork 或者 spawn 方式創建新的進程來執行其他任務

• 進程都有自己獨立的內存空間，所以進程需要通過進程間通信機制（IPC，Inter-Process Communication）來實現數據共享，具體的方式包括管道、信號、套接字、共享內存區等

一個進程還可以同時做多件事情，比如在 Word 里面同時進行打字、拼音檢查、打印等事情，也就是一個任務分為多個子任務同時進行，這些進程內的子任務被稱為線程（Thread）。

因為每個進程至少需要完成一件事情，也就是一個進程至少有一個線程。當要實現并發編程，也就是同時執行多任務時，有以下三種解決方案：

• 多進程，每個進程只有一個線程，但多個進程一起執行多個任務；

• 多線程，只啟動一個進程，但一個進程內開啟多個線程；

• 多進程+多線程，即啟動多個進程，每個進程又啟動多個線程，但這種方法非常復雜，實際很少使用

注意：真正的并行執行多任務只有在多核 CPU 上才可以實現，單核 CPU 系統中，真正的并發是不可能的，因為在某個時刻能夠獲得CPU的只有唯一的一個線程，多個線程共享了CPU的執行時間。

Python 是同時支持多進程和多線程的，下面就分別介紹多進程和多線程。

多進程

在 Unix/Linux 系統中，提供了一個 fork() 系統調用，它是一個特殊的函數，普通函數調用是調用一次，返回一次，但 fork 函數調用一次，返回兩次，因為調用該函數的是父進程，然后復制出一份子進程了，最后同時在父進程和子進程內返回，所以會返回兩次。

子進程返回的永遠是 0 ，而父進程會返回子進程的 ID，因為父進程可以復制多個子進程，所以需要記錄每個子進程的 ID，而子進程可以通過調用 getpid() 獲取父進程的 ID。

Python 中 os 模塊封裝了常見的系統調用，這就包括了 fork ，代碼示例如下：

import os
print('Process (%s) start...' % os.getpid())
# Only works on Unix/Linux/Mac:
pid = os.fork()
if pid == 0:
 print('I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid()))
else:
 print('I (%s) just created a child process (%s).' % (os.getpid(), pid))

運行結果：

Process (876) start...
I (876) just created a child process (877).
I am child process (877) and my parent is 876.

由于 windows 系統中是不存在 fork ，所以上述函數無法調用，但 Python 是跨平臺的，所以也還是有其他模塊可以實現多進程的功能，比如 multiprocessing模塊。

multiprocess

multiprocessing 模塊中提供了 Process 類來代表一個進程對象，接下來用一個下載文件的例子來說明采用多進程和不用多進程的差別。

首先是不采用多進程的例子：

def download_task(filename):
 '''模擬下載文件'''
 print('開始下載%s...' % filename)
 time_to_download = randint(5, 10)
 sleep(time_to_download)
 print('%s下載完成! 耗費了%d秒' % (filename, time_to_download))
def download_without_multiprocess():
 '''不采用多進程'''
 start = time()
 download_task('Python.pdf')
 download_task('nazha.mkv')
 end = time()
 print('總共耗費了%.2f秒.' % (end - start))
if __name__ == '__main__':
 download_without_multiprocess()

運行結果如下，這里用 randint 函數來隨機輸出當前下載文件的耗時，從結果看，程序運行時間等于兩個下載文件的任務時間總和。

開始下載Python.pdf...
Python.pdf下載完成! 耗費了9秒
開始下載nazha.mkv...
nazha.mkv下載完成! 耗費了9秒
總共耗費了18.00秒.

如果是采用多進程，例子如下所示：

def download_task(filename):
 '''模擬下載文件'''
 print('開始下載%s...' % filename)
 time_to_download = randint(5, 10)
 sleep(time_to_download)
 print('%s下載完成! 耗費了%d秒' % (filename, time_to_download))
def download_multiprocess():
 '''采用多進程'''
 start = time()
 p1 = Process(target=download_task, args=('Python.pdf',))
 p1.start()
 p2 = Process(target=download_task, args=('nazha.mkv',))
 p2.start()
 p1.join()
 p2.join()
 end = time()
 print('總共耗費了%.2f秒.' % (end - start))
if __name__ == '__main__':
 download_multiprocess()

這里多進程例子中，我們通過 Process 類創建了進程對象，通過 target 參數傳入一個函數表示進程需要執行的任務，args 是一個元組，表示傳遞給函數的參數，然后采用 start 來啟動進程，而 join 方法表示等待進程執行結束。

運行結果如下所示，耗時就不是兩個任務執行時間總和，速度上也是大大的提升了。

開始下載Python.pdf...
開始下載nazha.mkv...
Python.pdf下載完成! 耗費了5秒
nazha.mkv下載完成! 耗費了9秒
總共耗費了9.36秒.

Pool

上述例子是開啟了兩個進程，但如果需要開啟大量的子進程，上述代碼的寫法就不合適了，應該采用進程池的方式批量創建子進程，還是用下載文件的例子，但執行下部分的代碼如下所示：

import os
from multiprocessing import Process, Pool
from random import randint
from time import time, sleep
def download_multiprocess_pool():
 '''采用多進程，并用 pool 管理進程池'''
 start = time()
 filenames = ['Python.pdf', 'nazha.mkv', 'something.mp4', 'lena.png', 'lol.avi']
 # 進程池
 p = Pool(5)
 for i in range(5):
 p.apply_async(download_task, args=(filenames[i], ))
 print('Waiting for all subprocesses done...')
 # 關閉進程池
 p.close()
 # 等待所有進程完成任務
 p.join()
 end = time()
 print('總共耗費了%.2f秒.' % (end - start))
if __name__ == '__main__':
 download_multiprocess_pool()

代碼中 Pool 對象先創建了 5 個進程，然后 apply_async 方法就是并行啟動進程執行任務了，調用 join() 方法之前必須先調用 close() ，close() 主要是關閉進程池，所以執行該方法后就不能再添加新的進程對象了。然后 join() 就是等待所有進程執行完任務。

運行結果如下所示：

Waiting for all subprocesses done...
開始下載Python.pdf...
開始下載nazha.mkv...
開始下載something.mp4...
開始下載lena.png...
開始下載lol.avi...
nazha.mkv下載完成! 耗費了5秒
lena.png下載完成! 耗費了6秒
something.mp4下載完成! 耗費了7秒
Python.pdf下載完成! 耗費了8秒
lol.avi下載完成! 耗費了9秒
總共耗費了9.80秒.

子進程

大多數情況，子進程是一個外部進程，而非自身。在創建子進程后，我們還需要控制子進程的輸入和輸出。

subprocess 模塊可以讓我們很好地開啟子進程以及管理子進程的輸入和輸出。

下面是演示如何用 Python 演示命令 nslookup www.python.org，代碼如下所示：

import subprocess
print('$ nslookup www.python.org')
r = subprocess.call(['nslookup', 'www.python.org'])
print('Exit code:', r)

運行結果：

$ nslookup www.python.org
Server: 192.168.19.4
Address: 192.168.19.4#53
Non-authoritative answer:
www.python.org canonical name = python.map.fastly.net.
Name: python.map.fastly.net
Address: 199.27.79.223
Exit code: 0

如果子進程需要輸入，可以通過 communicate() 進行輸入，代碼如下所示：

import subprocess
print('$ nslookup')
p = subprocess.Popen(['nslookup'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output, err = p.communicate(b'set q=mx\npython.org\nexit\n')
print(output.decode('utf-8'))
print('Exit code:', p.returncode)

這段代碼就是執行命令 nslookup 時，輸入：

set q=mx
python.org
exit

運行結果：

$ nslookup
Server: 192.168.19.4
Address: 192.168.19.4#53
Non-authoritative answer:
python.org mail exchanger = 50 mail.python.org.
Authoritative answers can be found from:
mail.python.org internet address = 82.94.164.166
mail.python.org has AAAA address 2001:888:2000:d::a6
Exit code: 0

進程間通信

進程之間是需要通信的，multiprocess 模塊中也提供了 Queue、Pipes 等多種方式來交換數據。

這里以 Queue 為例，在父進程創建兩個子進程，一個往 Queue 寫入數據，另一個從 Queue 讀取數據。代碼如下：

import os
from multiprocessing import Process, Queue
import random
from time import time, sleep
# 寫數據進程執行的代碼:
def write(q):
 print('Process to write: %s' % os.getpid())
 for value in ['A', 'B', 'C']:
 print('Put %s to queue...' % value)
 q.put(value)
 sleep(random.random())
# 讀數據進程執行的代碼:
def read(q):
 print('Process to read: %s' % os.getpid())
 while True:
 value = q.get(True)
 print('Get %s from queue.' % value)
def ipc_queue():
 '''
 采用 Queue 實現進程間通信
 :return:
 '''
 # 父進程創建Queue，并傳給各個子進程：
 q = Queue()
 pw = Process(target=write, args=(q,))
 pr = Process(target=read, args=(q,))
 # 啟動子進程pw，寫入:
 pw.start()
 # 啟動子進程pr，讀取:
 pr.start()
 # 等待pw結束:
 pw.join()
 # pr進程里是死循環，無法等待其結束，只能強行終止:
 pr.terminate()
if __name__ == '__main__':
 ipc_queue()

運行結果如下所示：

Process to write: 24992
Put A to queue...
Process to read: 22836
Get A from queue.
Put B to queue...
Get B from queue.
Put C to queue...
Get C from queue.

到此，關于“Python進程和線程的概念是什么”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！