并行編程是一種編程模型，允許程序在多個(gè)處理器或內(nèi)核上同時(shí)運(yùn)行多個(gè)任務(wù)。該模型旨在更有效地使用處理器資源、減少處理時(shí)間并提高性能。

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

Python 提供了多種用于并行編程的工具和模塊。

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

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

*平方和立方計(jì)算示例
*

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ú)自在廚房做飯視為單進(jìn)程程序。我們可以將其比作多處理，即多個(gè)廚師在同一個(gè)廚房一起工作。

單一流程 - 單一烹飪

廚房里只有一名廚師。這位廚師將制作三道不同的菜肴：開胃菜、主菜和甜點(diǎn)。每道菜依次制作：
他準(zhǔn)備并完成了開胃菜。
他繼續(xù)主菜并完成它。
最后，他做了甜點(diǎn)。
問題：

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

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

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

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)我們檢查代碼示例時(shí)，我們看到結(jié)果列表為空。主要原因是使用多處理創(chuàng)建的進(jìn)程在自己的內(nèi)存空間中工作，獨(dú)立于主進(jìn)程。由于這種獨(dú)立性，子進(jìn)程中所做的更改不會(huì)直接反映在主進(jìn)程中的變量中。

Python 提供了以下共享數(shù)據(jù)的方法：

**1。共享內(nèi)存
**Value 和 Array 對(duì)象用于在操作之間共享數(shù)據(jù)。
值：共享單一數(shù)據(jù)類型（例如數(shù)字）。
數(shù)組：用于共享數(shù)據(jù)數(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)程之間傳輸數(shù)據(jù)。
multiprocessing.Queue 允許多個(gè)進(jìn)程發(fā)送和接收數(shù)據(jù)。

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)程之間的雙向數(shù)據(jù)傳輸。
它可用于發(fā)送和接收數(shù)據(jù)。

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)程內(nèi)存組織或避免訪問多個(gè)進(jìn)程之間共享的數(shù)據(jù)時(shí)的數(shù)據(jù)對(duì)齊和沖突問題。

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

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

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)程訪問共享數(shù)據(jù)。
在使用鎖的進(jìn)程完成之前，其他進(jìn)程會(huì)等待。

**多線程

多線程是一種并行編程模型，允許程序同時(shí)運(yùn)行多個(gè)線程。線程是在同一進(jìn)程中運(yùn)行的較小的獨(dú)立代碼單元，旨在通過共享資源實(shí)現(xiàn)更快、更高效的處理。
在Python中，threading模塊用于開發(fā)多線程應(yīng)用程序。然而，由于Python的全局解釋器鎖（GIL）機(jī)制，多線程在CPU密集型任務(wù)上提供的性能有限。因此，多線程通常是 I/O 密集型任務(wù)的首選。

線程是我們程序中的指令序列。

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)多個(gè)線程同時(shí)訪問相同資源時(shí)用于保證數(shù)據(jù)一致性和順序的技術(shù)。在Python中，threading模塊提供了幾種用于同步的工具。

**為什么需要線程同步？
**比賽條件：

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

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é)論：
**線程同步對(duì)于防止線程訪問共享資源時(shí)出現(xiàn)數(shù)據(jù)不一致至關(guān)重要。 Python中，Lock、RLock、Semaphore、Event、Condition等工具根據(jù)同步需求提供了有效的解決方案。使用哪種工具取決于應(yīng)用程序的需求和同步要求。

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