Pengurusan Proses dalam Python: Asas Pengaturcaraan Selari

Pengaturcaraan selari ialah model pengaturcaraan yang membenarkan atur cara menjalankan berbilang tugas secara serentak pada berbilang pemproses atau teras. Model ini bertujuan untuk menggunakan sumber pemproses dengan lebih cekap, mengurangkan masa pemprosesan dan meningkatkan prestasi.

Untuk menggambarkan pengaturcaraan selari dengan imej, kita boleh bayangkan bahawa kita menghadapi masalah. Sebelum kita memulakan pemprosesan selari, kita membahagikan masalah ini kepada sub-bahagian yang lebih kecil. Kami menganggap bahawa sub-bahagian ini adalah bebas antara satu sama lain dan tidak mempunyai pengetahuan tentang satu sama lain. Setiap sub-masalah diterjemahkan ke dalam tugas atau arahan yang lebih kecil. Tugas-tugas ini disusun dengan cara yang sesuai untuk kerja selari. Sebagai contoh, banyak arahan boleh dibuat untuk melaksanakan operasi yang sama pada set data. Tugasan ini kemudiannya diagihkan kepada pemproses yang berbeza. Setiap pemproses memproses arahan yang diberikan secara bebas dan selari. Proses ini mengurangkan jumlah masa pemprosesan dengan ketara dan membolehkan kami menggunakan sumber dengan lebih cekap.

Python menawarkan beberapa alatan dan modul untuk pengaturcaraan selari.

**Pemprosesan berbilang
**Ia membenarkan atur cara untuk mengambil kesempatan daripada keselarian sebenar dengan membolehkannya menjalankan berbilang proses pada masa yang sama. modul berbilang pemprosesan mengatasi batasan GIL (Global Interpreter Lock), membolehkan mencapai prestasi penuh pada pemproses berbilang teras.

Global Interpreter Lock (GIL) ialah mekanisme yang digunakan dalam pelaksanaan popular Python yang dipanggil CPython. GIL membenarkan hanya satu utas untuk melaksanakan kod bait Python pada satu masa. Ini ialah binaan yang mengehadkan keselarian sebenar apabila multithreading digunakan dalam Python.

*Contoh Pengiraan Kuasa Dua dan Kubus
*

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()

Mengapa Kita Memerlukan Multiprocessing Kita boleh menerangkan keperluan untuk multiprocessing dengan analogi tukang masak dan dapur. Anda boleh menganggap tukang masak memasak sendirian di dapur sebagai program satu proses. Kita boleh menyamakannya dengan berbilang pemprosesan apabila lebih daripada seorang tukang masak bekerja bersama-sama di dapur yang sama.

Proses Tunggal - Tukang Masak Tunggal

Hanya seorang tukang masak di dapur. Tukang masak ini akan membuat tiga hidangan berbeza: permulaan, hidangan utama dan pencuci mulut. Setiap hidangan dibuat mengikut giliran:
Dia menyediakan dan melengkapkan pemula.
Dia beralih ke hidangan utama dan menghabiskannya.
Akhirnya, dia membuat pencuci mulut.
Masalahnya:

Tidak kira berapa cepat tukang masak, dia bergilir-gilir dan ini membuang masa di dapur.
Jika tiga hidangan berbeza perlu dimasak pada masa yang sama, masa akan menjadi lebih lama.
Multiprocessing - Ramai Tukang Masak

Sekarang bayangkan terdapat tiga tukang masak di dapur yang sama. Masing-masing sedang menyediakan hidangan yang berbeza:
Seorang tukang masak membuat permulaan.
Tukang masak kedua menyediakan hidangan utama.
Tukang masak ketiga membuat pencuci mulut.
Kelebihan:

Tiga hidangan dibuat pada masa yang sama, yang mengurangkan jumlah masa dengan ketara.
Setiap tukang masak melakukan kerja sendiri secara bebas dan tidak dipengaruhi oleh yang lain.
Berkongsi Data Antara Proses dalam Python
Dalam Python, adalah mungkin untuk berkongsi data antara proses yang berbeza menggunakan modul multiprocessing. Walau bagaimanapun, setiap proses menggunakan ruang memorinya sendiri. Oleh itu, mekanisme khas digunakan untuk berkongsi data antara proses.

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()

Apabila kami memeriksa sampel kod, kami melihat bahawa senarai keputusan kosong. Sebab utama untuk ini ialah proses yang dibuat dengan multiprocessing berfungsi dalam ruang ingatan mereka sendiri, bebas daripada proses utama. Oleh kerana kebebasan ini, perubahan yang dibuat dalam proses kanak-kanak tidak dicerminkan secara langsung dalam pembolehubah dalam proses utama.

Python menyediakan kaedah berikut untuk berkongsi data:

**1. Memori Dikongsi
**Objek Nilai dan Tatasusunan digunakan untuk berkongsi data antara operasi.
Nilai: Berkongsi satu jenis data (contohnya, nombor).
Tatasusunan: Digunakan untuk berkongsi tatasusunan data.

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. Beratur
**Ia menggunakan struktur FIFO (First In First Out) untuk memindahkan data antara proses.
multiprocessing.Queue membenarkan berbilang proses untuk menghantar dan menerima data.

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. Paip
**multiprocessing.Pipe menyediakan pemindahan data dua hala antara dua proses.
Ia boleh digunakan untuk menghantar dan menerima data.

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()

*Padding Antara Proses
*“Padding antara proses” sering digunakan untuk organisasi memori proses atau untuk mengelakkan penjajaran data dan isu perlanggaran apabila mengakses data yang dikongsi antara berbilang proses.

Konsep ini penting terutamanya dalam kes seperti perkongsian palsu talian cache. Perkongsian palsu boleh menyebabkan kehilangan prestasi apabila pelbagai proses cuba menggunakan memori yang dikongsi pada masa yang sama. Ini disebabkan oleh perkongsian talian-cache dalam pemproses moden.

**Penyegerakan Antara Proses
**Dengan modul berbilang pemprosesan dalam Python, berbilang proses boleh berjalan serentak. Walau bagaimanapun, adalah penting untuk menggunakan penyegerakan apabila berbilang proses perlu mengakses data yang sama. Ini adalah perlu untuk memastikan ketekalan data dan mengelakkan isu seperti keadaan perlumbaan.

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()

Kunci membenarkan hanya satu proses untuk mengakses data yang dikongsi pada satu masa.
Sebelum proses menggunakan kunci selesai, proses lain menunggu.

**Pembacaan Berbilang

Multithreading ialah model pengaturcaraan selari yang membenarkan atur cara menjalankan berbilang benang secara serentak. Benang ialah unit kod bebas yang lebih kecil yang berjalan dalam proses yang sama dan bertujuan untuk pemprosesan yang lebih pantas dan cekap dengan berkongsi sumber.
Dalam Python, modul threading digunakan untuk membangunkan aplikasi multithreading. Walau bagaimanapun, disebabkan oleh mekanisme Global Interpreter Lock (GIL) Python, multithreading menyediakan prestasi terhad pada tugas terikat CPU. Oleh itu, multithreading biasanya lebih disukai untuk tugas terikat I/O.

benang ialah urutan arahan dalam program kami.

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()

**Penyegerakan Benang
**Penyegerakan benang ialah teknik yang digunakan untuk memastikan ketekalan dan susunan data apabila berbilang benang mengakses sumber yang sama secara serentak. Dalam Python, modul threading menyediakan beberapa alatan untuk penyegerakan.

**Mengapa Perlukan Penyegerakan Benang?
**Syarat Perlumbaan:

Apabila dua atau lebih urutan mengakses sumber yang dikongsi pada masa yang sama, ketidakkonsistenan data boleh berlaku.
Contohnya, satu urutan mungkin membaca data manakala urutan lain mengemas kini data yang sama.
*Ketekalan Data:
*
Penyelarasan antara urutan diperlukan untuk memastikan sumber yang dikongsi dikemas kini dengan betul.
Contoh Alat Penyegerakan dalam Python
**1. Kunci
**Apabila benang memperoleh kunci, ia menunggu kunci dilepaskan sebelum utas lain boleh mengakses sumber yang sama.

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-Acara

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}")

**Kesimpulan:
**Penyegerakan utas adalah penting untuk mengelakkan ketidakkonsistenan data apabila utas mengakses sumber yang dikongsi. Dalam Python, alatan seperti Lock, RLock, Semaphore, Event dan Condition menyediakan penyelesaian yang berkesan mengikut keperluan penyegerakan. Alat mana yang hendak digunakan bergantung pada keperluan aplikasi dan keperluan penyegerakan.

Atas ialah kandungan terperinci Pengurusan Proses dalam Python: Asas Pengaturcaraan Selari. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!