Panduan Pantas untuk Modul pemproses berbilang Python dengan Contoh

pengenalan

Modul pemproses berbilang dalam Python membolehkan anda mencipta dan mengurus proses, membolehkan anda memanfaatkan sepenuhnya berbilang pemproses pada mesin. Ia membantu anda mencapai pelaksanaan selari dengan menggunakan ruang memori yang berasingan untuk setiap proses, tidak seperti benang yang berkongsi ruang memori yang sama. Berikut ialah senarai kelas dan kaedah yang biasa digunakan dalam modul berbilang pemprosesan dengan contoh ringkas.

1. Proses

Kelas Proses ialah teras modul pemproses berbilang, membolehkan anda mencipta dan menjalankan proses baharu.

from multiprocessing import Process

def print_numbers():
    for i in range(5):
        print(i)

p = Process(target=print_numbers)
p.start()  # Starts a new process
p.join()   # Waits for the process to finish

2. mula ()

Memulakan aktiviti proses.

p = Process(target=print_numbers)
p.start()  # Runs the target function in a separate process

3. sertai([masa tamat])

Menyekat proses panggilan sehingga proses yang kaedah join() dipanggil ditamatkan. Secara pilihan, anda boleh menentukan tamat masa.

p = Process(target=print_numbers)
p.start()
p.join(2)  # Waits up to 2 seconds for the process to finish

4. is_alive()

Kembalikan Benar jika proses masih berjalan.

p = Process(target=print_numbers)
p.start()
print(p.is_alive())  # True if the process is still running

5. current_process()

Mengembalikan objek Proses semasa yang mewakili proses panggilan.

from multiprocessing import current_process

def print_current_process():
    print(current_process())

p = Process(target=print_current_process)
p.start()  # Prints the current process info

6. active_children()

Mengembalikan senarai semua objek Proses yang masih hidup.

p1 = Process(target=print_numbers)
p2 = Process(target=print_numbers)
p1.start()
p2.start()

print(Process.active_children())  # Lists all active child processes

7. cpu_count()

Mengembalikan bilangan CPU yang tersedia pada mesin.

from multiprocessing import cpu_count

print(cpu_count())  # Returns the number of CPUs on the machine

8. Kolam

Objek Pool menyediakan cara yang mudah untuk menyelaraskan pelaksanaan fungsi merentas berbilang nilai input. Ia menguruskan kumpulan proses pekerja.

from multiprocessing import Pool

def square(n):
    return n * n

with Pool(4) as pool:  # Pool with 4 worker processes
    result = pool.map(square, [1, 2, 3, 4, 5])

print(result)  # [1, 4, 9, 16, 25]

9. Beratur

Baris Gilir ialah struktur data kongsi yang membolehkan berbilang proses berkomunikasi dengan menghantar data antara mereka.

from multiprocessing import Process, Queue

def put_data(q):
    q.put([1, 2, 3])

def get_data(q):
    data = q.get()
    print(data)

q = Queue()
p1 = Process(target=put_data, args=(q,))
p2 = Process(target=get_data, args=(q,))

p1.start()
p2.start()
p1.join()
p2.join()

10. Kunci

Kunci memastikan bahawa hanya satu proses boleh mengakses sumber yang dikongsi pada satu masa.

from multiprocessing import Process, Lock

lock = Lock()

def print_numbers():
    with lock:
        for i in range(5):
            print(i)

p1 = Process(target=print_numbers)
p2 = Process(target=print_numbers)

p1.start()
p2.start()
p1.join()
p2.join()

11. Nilai dan Tatasusunan

Objek Nilai dan Tatasusunan membenarkan perkongsian jenis data dan tatasusunan mudah antara proses.

from multiprocessing import Process, Value

def increment(val):
    with val.get_lock():
        val.value += 1

shared_val = Value('i', 0)
processes = [Process(target=increment, args=(shared_val,)) for _ in range(10)]

for p in processes:
    p.start()

for p in processes:
    p.join()

print(shared_val.value)  # Output will be 10

12. Paip

A Pipe menyediakan saluran komunikasi dua hala antara dua proses.

from multiprocessing import Process, Pipe

def send_message(conn):
    conn.send("Hello from child")
    conn.close()

parent_conn, child_conn = Pipe()
p = Process(target=send_message, args=(child_conn,))
p.start()

print(parent_conn.recv())  # Receives data from the child process
p.join()

13. Pengurus

Pengurus membenarkan anda mencipta objek kongsi, seperti senarai dan kamus, yang boleh diubah suai berbilang proses secara serentak.

from multiprocessing import Process, Manager

def modify_list(shared_list):
    shared_list.append("New item")

with Manager() as manager:
    shared_list = manager.list([1, 2, 3])

    p = Process(target=modify_list, args=(shared_list,))
    p.start()
    p.join()

    print(shared_list)  # [1, 2, 3, "New item"]

14. Semafor

Semaphore membolehkan anda mengawal akses kepada sumber, membenarkan hanya beberapa proses tertentu untuk mengaksesnya pada satu masa.

from multiprocessing import Process, Semaphore
import time

sem = Semaphore(2)  # Only 2 processes can access the resource

def limited_access():
    with sem:
        print("Accessing resource")
        time.sleep(2)

processes = [Process(target=limited_access) for _ in range(5)]

for p in processes:
    p.start()

for p in processes:
    p.join()

Kesimpulan

Modul pemproses berbilang dalam Python direka bentuk untuk memanfaatkan sepenuhnya berbilang pemproses pada mesin. Daripada mencipta dan mengurus proses menggunakan Proses, kepada mengawal sumber dikongsi dengan Lock dan Semaphore, dan memudahkan komunikasi melalui Queue dan Paip, modul berbilang pemprosesan adalah penting untuk menyelaraskan tugas dalam aplikasi Python.

Atas ialah kandungan terperinci Panduan Pantas untuk Modul pemproses berbilang Python dengan Contoh. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!