平行程式設(shè)計(jì)是一種程式設(shè)計(jì)模型，允許程式在多個(gè)處理器或核心上同時(shí)執(zhí)行多個(gè)任務(wù)。該模型旨在更有效地使用處理器資源、減少處理時(shí)間並提高效能。

為了用圖像說(shuō)明並行編程，我們可以想像我們遇到了一個(gè)問(wèn)題。在開(kāi)始並行處理之前，我們將這個(gè)問(wèn)題分成更小的子部分。我們假設(shè)這些子部分彼此獨(dú)立且彼此不了解。每個(gè)子問(wèn)題都轉(zhuǎn)換為更小的任務(wù)或指令。這些任務(wù)以適合併行工作的方式組織。例如，可以建立許多指令來(lái)對(duì)資料集執(zhí)行相同的操作。然後這些任務(wù)被分配給不同的處理器。每個(gè)處理器獨(dú)立且並行地處理其分配的指令。這個(gè)過(guò)程顯著減少了總處理時(shí)間，使我們能夠更有效地使用資源。

Python 提供了多種用於平行程式設(shè)計(jì)的工具和模組。

**多處理
**它允許程式同時(shí)運(yùn)行多個(gè)進(jìn)程，從而利用真正的並行性。多處理模組克服了 GIL（全域解釋器鎖）的限制，允許在多核心處理器上實(shí)現(xiàn)全部效能。

全域解釋器鎖定（GIL）是流行的 Python 實(shí)作（稱(chēng)為 CPython）中使用的一種機(jī)制。 GIL 一次只允許一個(gè)執(zhí)行緒執(zhí)行 Python 字節(jié)碼。當(dāng)在 Python 中使用多執(zhí)行緒時(shí)，這種結(jié)構(gòu)會(huì)限制真正的並行性。

*平方和立方計(jì)算範(fàn)例
*

from multiprocessing import Process

def print_square(numbers):
    for n in numbers:
        print(f"Square of {n} is {n * n}")

def print_cube(numbers):
    for n in numbers:
        print(f"Cube of {n} is {n * n * n}")

if __name__ == "__main__":
    numbers = [2, 3, 4, 5]  

    # ??lemler (processes) olu?turma
    process1 = Process(target=print_square, args=(numbers,))
    process2 = Process(target=print_cube, args=(numbers,))

    # ??lemleri ba?latma
    process1.start()
    process2.start()

    # ??lemlerin tamamlanmas?n? bekleme
    process1.join()
    process2.join()

為什麼我們需要多重處理 我們可以用廚師和廚房的類(lèi)比來(lái)解釋多重處理的需求。您可以將廚師獨(dú)自在廚房做飯視為單一進(jìn)程程序。我們可以將其比作多處理，即多個(gè)廚師在同一個(gè)廚房一起工作。

單一流程 - 單一烹飪

廚房裡只有一名廚師。這位廚師將製作三道不同的菜餚：開(kāi)胃菜、主菜和甜點(diǎn)。每道菜依序製作：
他準(zhǔn)備並完成了開(kāi)胃菜。
他繼續(xù)主菜並完成它。
最後，他做了甜點(diǎn)。
問(wèn)題：

無(wú)論廚師有多快，他或她都會(huì)輪流，這會(huì)浪費(fèi)廚房時(shí)間。
如果需要同時(shí)煮三種不同的菜餚，時(shí)間會(huì)更長(zhǎng)。
多重處理 - 許多廚師

現(xiàn)在想像一下同一個(gè)廚房裡有三個(gè)廚師。每個(gè)人都在準(zhǔn)備不同的菜餚：
開(kāi)胃菜由一名廚師製作。
第二位廚師準(zhǔn)備主菜。
第三位廚師做甜點(diǎn)。
優(yōu)點(diǎn)：

三道菜同時(shí)製作，大大減少了總時(shí)間。
每個(gè)廚師獨(dú)立做自己的工作，不受其他人的影響。
在 Python 中的進(jìn)程之間共享資料
在Python中，可以使用多處理模組在不同進(jìn)程之間共用資料。但是，每個(gè)進(jìn)程都使用自己的記憶體空間。因此，使用特殊的機(jī)制在進(jìn)程之間共享資料。

from multiprocessing import Process

def print_square(numbers):
    for n in numbers:
        print(f"Square of {n} is {n * n}")

def print_cube(numbers):
    for n in numbers:
        print(f"Cube of {n} is {n * n * n}")

if __name__ == "__main__":
    numbers = [2, 3, 4, 5]  

    # ??lemler (processes) olu?turma
    process1 = Process(target=print_square, args=(numbers,))
    process2 = Process(target=print_cube, args=(numbers,))

    # ??lemleri ba?latma
    process1.start()
    process2.start()

    # ??lemlerin tamamlanmas?n? bekleme
    process1.join()
    process2.join()

當(dāng)我們檢查程式碼範(fàn)例時(shí)，我們看到結(jié)果清單為空。主要原因是使用多處理創(chuàng)建的進(jìn)程在自己的記憶體空間中工作，獨(dú)立於主進(jìn)程。由於這種獨(dú)立性，子進(jìn)程中所做的更改不會(huì)直接反映在主進(jìn)程中的變數(shù)中。

Python 提供了以下共享資料的方法：

**1。共享記憶體
**Value 和 Array 物件用於在操作之間共用資料。
值：共享單一資料類(lèi)型（例如數(shù)字）。
數(shù)組：用於共享資料數(shù)組。

import multiprocessing

result = []

def square_of_list(mylist):
    for num in mylist:
        result.append(num**2)
    return result

mylist= [1,3,4,5]

p1 = multiprocessing.Process(target=square_of_list,args=(mylist,))
p1.start()
p1.join()

print(result) # [] Bo? Liste

**2。隊(duì)列
**它使用 FIFO（先進(jìn)先出）結(jié)構(gòu)在進(jìn)程之間傳輸資料。
multiprocessing.Queue 允許多個(gè)進(jìn)程發(fā)送和接收資料。

from multiprocessing import Process, Value

def increment(shared_value):
    for _ in range(1000):
        shared_value.value += 1  

if __name__ == "__main__":
    shared_value = Value('i', 0)  
    processes = [Process(target=increment, args=(shared_value,)) for _ in range(5)]

    for p in processes:
        p.start()
    for p in processes:
        p.join()

    print(f"Sonu?: {shared_value.value}")

**3。管道
**multiprocessing.Pipe 提供兩個(gè)進(jìn)程之間的雙向資料傳輸。
它可用於發(fā)送和接收資料。

from multiprocessing import Process, Queue

def producer(queue):
    for i in range(5):
        queue.put(i)  # Kuyru?a veri ekle
        print(f"üretildi: {i}")

def consumer(queue):
    while not queue.empty():
        item = queue.get()  
        print(f"Tüketildi: {item}")

if __name__ == "__main__":
    queue = Queue()

    producer_process = Process(target=producer, args=(queue,))
    consumer_process = Process(target=consumer, args=(queue,))

    producer_process.start()
    producer_process.join()

    consumer_process.start()
    consumer_process.join()

*進(jìn)程之間的填充
*「進(jìn)程之間的填充」通常用於進(jìn)程記憶體組織或避免存取多個(gè)進(jìn)程之間共享的資料時(shí)的資料對(duì)齊和衝突問(wèn)題。

這個(gè)概念在快取行錯(cuò)誤共享等情況下尤其重要。當(dāng)多個(gè)進(jìn)程嘗試同時(shí)使用共享記憶體時(shí)，錯(cuò)誤共享可能會(huì)導(dǎo)致效能損失。這是由於現(xiàn)代處理器中快取行的共享。

**進(jìn)程之間的同步
**使用Python中的多處理模組，多個(gè)進(jìn)程可以同時(shí)運(yùn)作。然而，當(dāng)多個(gè)進(jìn)程需要存取相同的資料時(shí)，使用同步非常重要。這是確保數(shù)據(jù)一致性並避免競(jìng)爭(zhēng)條件等問(wèn)題所必需的。

from multiprocessing import Process, Pipe

def send_data(conn):
    conn.send([1, 2, 3, 4])  
    conn.close()

if __name__ == "__main__":
    parent_conn, child_conn = Pipe()  

    process = Process(target=send_data, args=(child_conn,))
    process.start()

    print(f"Al?nan veri: {parent_conn.recv()}")  # Veri al
    process.join()

鎖定一次只允許一個(gè)程序存取共享資料。
在使用鎖的進(jìn)程完成之前，其他進(jìn)程會(huì)等待。

**多執(zhí)行緒

多執(zhí)行緒是一種平行程式設(shè)計(jì)模型，允許程式同時(shí)運(yùn)行多個(gè)執(zhí)行緒。執(zhí)行緒是在同一進(jìn)程中運(yùn)行的較小的獨(dú)立程式碼單元，旨在透過(guò)共享資源實(shí)現(xiàn)更快、更有效率的處理。
在Python中，threading模組用於開(kāi)發(fā)多執(zhí)行緒應(yīng)用程式。然而，由於Python的全域解釋器鎖定（GIL）機(jī)制，多執(zhí)行緒在CPU密集型任務(wù)上提供的效能有限。因此，多執(zhí)行緒通常是 I/O 密集型任務(wù)的首選。

執(zhí)行緒是我們程式中的指令序列。

from multiprocessing import Process

def print_square(numbers):
    for n in numbers:
        print(f"Square of {n} is {n * n}")

def print_cube(numbers):
    for n in numbers:
        print(f"Cube of {n} is {n * n * n}")

if __name__ == "__main__":
    numbers = [2, 3, 4, 5]  

    # ??lemler (processes) olu?turma
    process1 = Process(target=print_square, args=(numbers,))
    process2 = Process(target=print_cube, args=(numbers,))

    # ??lemleri ba?latma
    process1.start()
    process2.start()

    # ??lemlerin tamamlanmas?n? bekleme
    process1.join()
    process2.join()

**線程同步
**執(zhí)行緒同步是當(dāng)多個(gè)執(zhí)行緒同時(shí)存取相同資源時(shí)用於保證資料一致性和順序的技術(shù)。在Python中，threading模組提供了幾種用於同步的工具。

**為什麼需要執(zhí)行緒同步？
**比賽條件：

當(dāng)兩個(gè)或多個(gè)執(zhí)行緒同時(shí)存取共享資源時(shí)，可能會(huì)出現(xiàn)資料不一致的情況。
例如，一個(gè)執(zhí)行緒可能讀取數(shù)據(jù)，而另一個(gè)執(zhí)行緒更新相同的數(shù)據(jù)。
*資料一致性：
*
需要執(zhí)行緒之間的協(xié)調(diào)來(lái)確保共享資源正確更新。
Python 中的同步工具範(fàn)例
**1.鎖
**當(dāng)一個(gè)執(zhí)行緒取得鎖時(shí)，它會(huì)等待鎖被釋放，然後其他執(zhí)行緒才能存取相同資源。

import multiprocessing

result = []

def square_of_list(mylist):
    for num in mylist:
        result.append(num**2)
    return result

mylist= [1,3,4,5]

p1 = multiprocessing.Process(target=square_of_list,args=(mylist,))
p1.start()
p1.join()

print(result) # [] Bo? Liste

2 活動(dòng)

from multiprocessing import Process, Value

def increment(shared_value):
    for _ in range(1000):
        shared_value.value += 1  

if __name__ == "__main__":
    shared_value = Value('i', 0)  
    processes = [Process(target=increment, args=(shared_value,)) for _ in range(5)]

    for p in processes:
        p.start()
    for p in processes:
        p.join()

    print(f"Sonu?: {shared_value.value}")

**結(jié)論：
**執(zhí)行緒同步對(duì)於防止執(zhí)行緒存取共享資源時(shí)出現(xiàn)資料不一致至關(guān)重要。 Python中，Lock、RLock、Semaphore、Event、Condition等工具根據(jù)同步需求提供了有效的解決方案。使用哪種工具取決於應(yīng)用程式的需求和同步要求。

以上是Python 中的進(jìn)程管理：平行程式設(shè)計(jì)基礎(chǔ)的詳細(xì)內(nèi)容。更多資訊請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！