什么是多進程

多進程是計算機編程中的一個概念，也可以說是一種可用于實現(xiàn)并行性和利用多個 CPU 內(nèi)核或處理器并發(fā)執(zhí)行任務(wù)的技術(shù)。這種技術(shù)尤其適用于受 CPU 限制的任務(wù)，并行執(zhí)行可以提高程序的性能。Python 提供了多進程模塊來處理多個進程。

多進程（Multiprocessing）是一種計算機編程和執(zhí)行范式，涉及多個進程或程序的同時執(zhí)行，方法是根據(jù)我們正在處理的問題或設(shè)置，在單臺計算機或多臺計算機上利用多個 CPU 內(nèi)核或處理器。

多進程是并行的一種形式，旨在通過允許任務(wù)并發(fā)執(zhí)行來提高程序性能和效率，從而有效利用可用的計算資源。

下文將討論多進程的幾個組成部分。

• 1. 進程：每個任務(wù)或工作單位或進程都封裝在一個單獨的進程中，這是一個獨立的程序執(zhí)行單元。這些進程可以相互獨立地同時運行。

• 2. 并行執(zhí)行：多個進程（如計算、數(shù)據(jù)處理或多個請求處理）可以通過多進程并行執(zhí)行，從而同時執(zhí)行任務(wù)。

• 3. 資源利用：多處理是一種技術(shù)，通過將任務(wù)分配給多個 CPU 內(nèi)核，有效利用現(xiàn)代計算機的處理能力，尤其是多核處理器（如四核或八核）。

• 4. 隔離：在多進程中，進程之間是相互隔離的。這意味著，一個進程的操作或故障不會直接影響其他進程。這種隔離處理增強了系統(tǒng)的穩(wěn)定性。

• 5. 進程間通信（IPC）：進程間通信機制（如共享內(nèi)存、管道、隊列和套接字）允許進程交換數(shù)據(jù)并協(xié)調(diào)其活動。

• 6. 可擴展性：多進程可以進行擴展，以利用許多處理器甚至分布式計算集群的能力來解決計算密集型問題。

多線程與多進程的區(qū)別

想象一下你和兩個助手在廚房里做飯。多線程就像是讓這兩個助手在同一個廚房里完成一項任務(wù)。這無疑會加快進程，兩個人同時完成一項任務(wù)。在同一個廚房工作的這些助手可以共享相同的食材，可以互相交流，可以輕松分擔(dān)任務(wù)。但是也可能會變得混亂，他們在工作時可能會相互碰撞，從而破壞所有的進度。

多進程就像有兩個幫手，在兩個不同的廚房工作，使用各自的食材和個人空間。這些助手可以獨立工作，互不干擾，但如果他們需要分享食材或交談，就必須使用電話。

從這個例子中，我們可以了解到，多線程是一種很好的技術(shù)，適用于助手不需要頻繁移動的任務(wù)，因為處理器不需要使用大量資源。然而多進程更適合需要大量移動的任務(wù)，或者從技術(shù)上講需要同時使用內(nèi)核的大量資源的任務(wù)。

如果我們用一句話來定義，多線程主要是實現(xiàn)并發(fā)性，允許任務(wù)在時間上重疊，而多進程則是實現(xiàn)真正的并行性，因為每個進程都在不同的 CPU 內(nèi)核或處理器上獨立運行。

在 python 中執(zhí)行多進程的第一步是導(dǎo)入模塊。

import multiprocessing

我們要使用多進程來運行一個程序。讓我們創(chuàng)建一個用戶自定義程序示例，看看如何操作：

def test():
  print("This is my sample program")

test()

# Output:
# This is my sample program

要使用多進程調(diào)用該程序，我們將使用以下代碼。

import multiprocessing

def test01():
  print("This is a sample multiprocessing program")

if __name__ == "__main__":
  m = multiprocessing.Process(target=test01)
  print("this is my main program")

  # start the program
  m.start()

  # stop/terminate the program and release the resource
  m.join()

在上面的代碼中，我們通過 main 函數(shù)使用多進程調(diào)用我們要處理的程序。并且確保只有在直接執(zhí)行該腳本時，而不是作為模塊導(dǎo)入時，代碼才會運行。

我們還可以在其他函數(shù)中使用多進程，執(zhí)行一些邏輯運算，下面給出了一個例子。

import multiprocessing

def square(n):
  return n**2

if __name__ == '__main__':
  with multiprocessing.Pool(processes=5) as pool:
    out = pool.map(square, [12,2,3,5,23,14,26,8,4,6])
    print(out)

# Output:
# [144, 4, 9, 25, 529, 196, 676, 64, 16, 36]

并行執(zhí)行函數(shù)

運行多個進程

我們可以使用多進程技術(shù)在多個內(nèi)核上運行多個進程。我們創(chuàng)建并啟動多個進程，每個進程都運行帶有一組參數(shù)的函數(shù) "workers"（如下代碼所示）。我們使用 "args "來指定函數(shù)要使用的參數(shù)列表。

在下面的代碼中，我們使用多進程的概念，使用 4 個進程來處理程序。為此，我們使用了 python 中多進程模塊的 Process 方法。

def workers(num):
    print(f"Worker number {num}")

if __name__ == "__main__":
    processes = []
    for i in range(4):
        process = multiprocessing.Process(target=workers, args=(i,))
        processes.append(process)
        process.start()

    for process in processes:
        process.join()

Output:
Worker number 0
Worker number 1
Worker number 2
Worker number 3

進程間共享數(shù)據(jù)

使用 multiprocessing.Queue

multiprocessing.Queue 是 Python 編程語言中的一個類，由 multiprocessing 模塊提供，我們用它來執(zhí)行 python 中的多進程處理。這里的 Queue 用于促進多進程程序中不同進程之間的通信和數(shù)據(jù)交換。

multiprocessing.Queue 的一些主要功能和用途如下：

• • 進程間通信：它允許多個進程通過使用共同的數(shù)據(jù)結(jié)構(gòu)（隊列）安全地交換數(shù)據(jù)。每個進程都可以將數(shù)據(jù)放入隊列或從中檢索數(shù)據(jù)。

• • 線程安全：它的設(shè)計方式確保了線程安全和進程安全，這意味著它可以在多線程或多進程環(huán)境中安全使用，而不會出現(xiàn)競賽條件或數(shù)據(jù)損壞。

• • 先進先出隊列始終遵循 FIFO 即先進先出原則，這意味著第一個放入隊列的項目也將是第一個出來的項目。

• • 阻塞操作：當(dāng)一個進程試圖從一個空隊列中檢索一個項目或向一個已填滿的隊列中插入一個項目時，該操作將阻塞，直到條件發(fā)生變化。這種進程/行為對于進程間的同步非常有用。

在使用 Python 進行并行或并發(fā)處理時，multiprocessing.Queue 是一個非常有用的工具，尤其是在多個進程需要共享和協(xié)調(diào)數(shù)據(jù)的情況下。

下面的單元格給出了一個如何使用 multiprocessing.Queue 的示例：生產(chǎn)者進程生產(chǎn)數(shù)據(jù)或?qū)?shù)據(jù)放入隊列，消費者進程從隊列中消費數(shù)據(jù)。多進程隊列 確保了兩個進程之間安全的數(shù)據(jù)交換。

import multiprocessing
import time
#defining our function we want to apply multiprocessing on
#01 the producer function to add elements in the queue
def producer(q):
  for item in range(5):
    q.put(item)
    print(f"Produced:  {item}")
#02 consumer function to get elements from the queue
def consumer(q):
  while True:
    item = q.get()
    if item is None:
      break
    print(f"Consumed: {item}")
if __name__ == "__main__":
  #creating a multiprocessing queue
  q = multiprocessing.Queue()
  #creating the producer and consumer processes
  producer_process = multiprocessing.Process(target=producer, args=(q,))
  consumer_process = multiprocessing.Process(target=consumer, args=(q,))
  #starting the processes
  producer_process.start()
  consumer_process.start()
  #finish the producer, signal the consumer to exit
  producer_process.join()
  q.put(None) #signaling the consumer about no more data in the queue
  consumer_process.join()
Output:
Produced:  0
Produced:  1
Consumed: 0Produced:  2
Produced:  3Consumed: 1
Produced:  4
Consumed: 2
Consumed: 3
Consumed: 4

進程池

使用 multiprocessing.Pool 類

multiprocessing.Pool 是 python 中 multiprocessing 模塊提供的另一個類。它用于創(chuàng)建和管理可并行執(zhí)行任務(wù)的進程池。該類簡化了并行任務(wù)并將其分配給多個進程的過程。

下面列出了 multiprocessing.Pool 的一些功能和用途。

• • multiprocessing.Pool 用于在 python 中實現(xiàn)并行處理。它允許我們并發(fā)執(zhí)行多個任務(wù)，充分利用多核 CPU 的優(yōu)勢，并有可能提高 CPU 相關(guān)操作的性能。

• • 任務(wù)分配：我們可以使用 multiprocessing.Pool 在工作進程池中分配任務(wù)。它對工作進程的管理進行了抽象，使并行工作變得更容易。

• • 資源管理：進程池會根據(jù)可用的 CPU 內(nèi)核自動管理工作進程的創(chuàng)建和銷毀。我們可以指定要使用的工作進程數(shù)量，其余的由進程池處理。

• • 負(fù)載平衡：進程池會在工作進程之間有效分配任務(wù)，確保每個工作進程都能獲得同等的工作量。這種負(fù)載平衡對于優(yōu)化并行處理至關(guān)重要。

• • 結(jié)果收集：我們可以從工作進程中收集結(jié)果。當(dāng)任務(wù)產(chǎn)生的結(jié)果需要匯總或進一步處理時，這一點尤其有用。

• • 上下文管理器：它還可以充當(dāng)上下文管理器，確保在不再需要時正確關(guān)閉池并終止工作進程。

下面的單元格顯示了一個使用 multiprocessing.Pool 的示例代碼，通過一個返回給定數(shù)字平方的簡單函數(shù)對進程進行多進程處理。

def square(x):
  return x**2 
if __name__=='__main__':
  #create a multiprocessing pool with 4 worker processes
  with multiprocessing.Pool(processes=4) as pool:
    #distribute the tasks among worker processes and collect results
    results = pool.map(square, [2,5,3,2,1,7,8,5,6,2,2,3])
    #print the results
    print(results)
Output:
[4, 25, 9, 4, 1, 49, 64, 25, 36, 4, 4, 9]

以上就是深入探究Python中的多進程用法實例的詳細(xì)內(nèi)容，更多關(guān)于Python 多進程的資料請關(guān)注腳本之家其它相關(guān)文章！