Memahami Threading dan Multiprocessing dalam Python: Panduan Komprehensif

pengenalan

Dalam Python, konsep benang dan pemprosesan berbilang sering dibincangkan semasa mengoptimumkan aplikasi untuk prestasi, terutamanya apabila ia melibatkan pelaksanaan serentak atau selari. Walaupun terdapat pertindihan dalam istilah, kedua-dua pendekatan ini pada asasnya berbeza.

Blog ini akan membantu menjelaskan kekeliruan sekitar benang dan pemprosesan berbilang, menerangkan masa untuk menggunakan setiap satu dan memberikan contoh yang berkaitan untuk setiap konsep.

Threading lwn. Multiprocessing: Perbezaan Utama

Sebelum menyelami contoh dan kes penggunaan, mari kita gariskan perbezaan utama:

• Benang: Merujuk kepada menjalankan berbilang utas (unit yang lebih kecil bagi sesuatu proses) dalam satu proses. Benang berkongsi ruang memori yang sama, yang menjadikannya ringan. Walau bagaimanapun, Global Interpreter Lock (GIL) Python mengehadkan keselarian sebenar threading untuk tugas terikat CPU.

• Pemprosesan Berbilang: Melibatkan menjalankan berbilang proses, setiap satu dengan ruang ingatannya sendiri. Proses lebih berat daripada benang tetapi boleh mencapai keselarian sebenar kerana ia tidak berkongsi ingatan. Pendekatan ini sesuai untuk tugas terikat CPU yang memerlukan penggunaan teras penuh.

Apakah Threading?

Threading ialah cara untuk menjalankan berbilang tugas secara serentak dalam proses yang sama. Tugasan ini dikendalikan oleh benang, yang merupakan unit perlaksanaan yang berasingan dan ringan yang berkongsi ruang memori yang sama. Threading bermanfaat untuk operasi terikat I/O, seperti pembacaan fail, permintaan rangkaian atau pertanyaan pangkalan data, yang mana program utama menghabiskan banyak masa menunggu sumber luaran.

Bila Menggunakan Threading

• Apabila program anda terikat I/O (cth., membaca/menulis fail, membuat permintaan rangkaian).
• Apabila tugasan menghabiskan banyak masa menunggu operasi input atau output.
• Apabila anda memerlukan konkurensi ringan dalam satu proses.

Contoh: Benang Asas

import threading
import time

def print_numbers():
    for i in range(5):
        print(i)
        time.sleep(1)

def print_letters():
    for letter in ['a', 'b', 'c', 'd', 'e']:
        print(letter)
        time.sleep(1)

# Create two threads
t1 = threading.Thread(target=print_numbers)
t2 = threading.Thread(target=print_letters)

# Start both threads
t1.start()
t2.start()

# Wait for both threads to complete
t1.join()
t2.join()

print("Both threads finished execution.")

Dalam contoh di atas, dua utas berjalan serentak: satu mencetak nombor dan satu lagi mencetak huruf. Panggilan sleep() mensimulasikan operasi I/O dan atur cara boleh bertukar antara urutan semasa menunggu ini.

Masalah dengan Threading: Kunci Jurubahasa Global (GIL)

GIL Python ialah mekanisme yang menghalang berbilang benang asli daripada melaksanakan kod bait Python secara serentak. Ia memastikan bahawa hanya satu utas berjalan pada satu masa, walaupun beberapa utas aktif dalam proses.

Penghadan ini menjadikan penjalinan tidak sesuai untuk tugas terikat CPU yang memerlukan keselarian sebenar kerana utas tidak dapat menggunakan berbilang teras sepenuhnya disebabkan oleh GIL.

Apakah itu Multiprocessing?

Pemprosesan berbilang membolehkan anda menjalankan berbilang proses serentak, di mana setiap proses mempunyai ruang ingatan sendiri. Memandangkan proses tidak berkongsi memori, tiada sekatan GIL, membenarkan pelaksanaan selari benar pada berbilang teras CPU. Pemprosesan berbilang sesuai untuk tugas terikat CPU yang perlu memaksimumkan penggunaan CPU.

Bila Menggunakan Multiprocessing

• Apabila atur cara anda terikat kepada CPU (cth., melakukan pengiraan berat, pemprosesan data).
• Apabila anda memerlukan keselarian sebenar tanpa perkongsian memori.
• Apabila anda ingin menjalankan berbilang kejadian tugas bebas serentak.

Contoh: Asas Multiprocessing

import multiprocessing
import time

def print_numbers():
    for i in range(5):
        print(i)
        time.sleep(1)

def print_letters():
    for letter in ['a', 'b', 'c', 'd', 'e']:
        print(letter)
        time.sleep(1)

if __name__ == "__main__":
    # Create two processes
    p1 = multiprocessing.Process(target=print_numbers)
    p2 = multiprocessing.Process(target=print_letters)

    # Start both processes
    p1.start()
    p2.start()

    # Wait for both processes to complete
    p1.join()
    p2.join()

    print("Both processes finished execution.")

Dalam contoh ini, dua proses berasingan berjalan serentak. Tidak seperti benang, setiap proses mempunyai ruang ingatan sendiri dan ia dilaksanakan secara bebas tanpa gangguan daripada GIL.

Pengasingan Memori dalam Multiprocessing

Satu perbezaan utama antara threading dan multiprocessing ialah proses tidak berkongsi memori. Walaupun ini memastikan tiada gangguan antara proses, ini juga bermakna perkongsian data antara proses memerlukan mekanisme khas, seperti objek Baris Gilir, Paip atau Pengurus yang disediakan oleh modul berbilang pemprosesan.

Threading lwn. Multiprocessing: Memilih Alat yang Tepat

Sekarang kita memahami cara kedua-dua pendekatan berfungsi, mari kita pecahkan bila hendak memilih penjalinan atau pemproses berbilang berdasarkan jenis tugas:

Performance Considerations

Threading Performance

Threading excels in scenarios where the program waits on external resources (disk I/O, network). Since threads can work concurrently during these wait times, threading can help boost performance.

However, due to the GIL, CPU-bound tasks do not benefit much from threading because only one thread can execute at a time.

Multiprocessing Performance

Multiprocessing allows true parallelism by running multiple processes across different CPU cores. Each process runs in its own memory space, bypassing the GIL and making it ideal for CPU-bound tasks.

However, creating processes is more resource-intensive than creating threads, and inter-process communication can slow things down if there's a lot of data sharing between processes.

A Practical Example: Threading vs. Multiprocessing for CPU-bound Tasks

Let's compare threading and multiprocessing for a CPU-bound task like calculating the sum of squares for a large list.

Threading Example for CPU-bound Task

import threading

def calculate_squares(numbers):
    result = sum([n * n for n in numbers])
    print(result)

numbers = range(1, 10000000)
t1 = threading.Thread(target=calculate_squares, args=(numbers,))
t2 = threading.Thread(target=calculate_squares, args=(numbers,))

t1.start()
t2.start()

t1.join()
t2.join()

Due to the GIL, this example will not see significant performance improvements over a single-threaded version because the threads can't run simultaneously for CPU-bound operations.

Multiprocessing Example for CPU-bound Task

import multiprocessing

def calculate_squares(numbers):
    result = sum([n * n for n in numbers])
    print(result)

if __name__ == "__main__":
    numbers = range(1, 10000000)
    p1 = multiprocessing.Process(target=calculate_squares, args=(numbers,))
    p2 = multiprocessing.Process(target=calculate_squares, args=(numbers,))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

In the multiprocessing example, you'll notice a performance boost since both processes run in parallel across different CPU cores, fully utilizing the machine's computational resources.

Conclusion

Understanding the difference between threading and multiprocessing is crucial for writing efficient Python programs. Here’s a quick recap:

• Use threading for I/O-bound tasks where your program spends a lot of time waiting for resources.
• Use multiprocessing for CPU-bound tasks to maximize performance through parallel execution.

Knowing when to use which approach can lead to significant performance improvements and efficient use of resources.

Atas ialah kandungan terperinci Memahami Threading dan Multiprocessing dalam Python: Panduan Komprehensif. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!