Memahami Multi-Pemrosesan dalam Python: Panduan yang Disederhanakan

Menjalankan aplikasi yang membutuhkan banyak sumber daya atau tugas pemrosesan data? Server Khusus AlexHost menyediakan lingkungan yang sempurna untuk memanfaatkan kekuatan multiprosesor dalam Python. Dengan CPU berkinerja tinggi, sumber daya khusus, dan infrastruktur yang kuat, AlexHost memastikan aplikasi Anda berjalan secara efisien, bahkan di bawah beban komputasi yang berat. Baik Anda sedang mengolah data, menjalankan simulasi, atau menerapkan model pembelajaran mesin, solusi AlexHost dirancang untuk memaksimalkan produktivitas Anda.

Modul multiprosesor Python memungkinkan Anda untuk menjalankan beberapa proses secara bersamaan, sehingga memungkinkan untuk memanfaatkan beberapa inti CPU dan meningkatkan kinerja tugas-tugas yang terikat pada CPU. Hal ini sangat berguna ketika Anda memiliki tugas-tugas yang intensif secara komputasi seperti pemrosesan data, pembelajaran mesin, atau simulasi. Panduan ini memberikan penjelasan yang disederhanakan tentang cara kerja multiprosesor dalam Python dan cara menggunakannya secara efektif.

Mengapa Menggunakan Multiprocessing?

Python menggunakan Global Interpreter Lock (GIL), yang memungkinkan hanya satu thread untuk mengeksekusi bytecode Python dalam satu waktu. Hal ini membuat penggunaan multithreading untuk tugas-tugas yang terikat dengan CPU menjadi lebih sulit karena hanya satu thread yang dapat berjalan dalam satu waktu, bahkan pada prosesor multi-core. Di sisi lain, multiprocessing menciptakan ruang memori yang terpisah untuk setiap proses, sehingga setiap proses dapat dijalankan secara paralel dan sepenuhnya memanfaatkan beberapa inti CPU.

Perbedaan Utama Antara Multiprocessing dan Multithreading:

Multiproses: Menggunakan ruang memori yang terpisah untuk setiap proses, melewati GIL dan memungkinkan paralelisme yang sebenarnya.
Multithreading: Membagi ruang memori di antara thread tetapi dibatasi oleh GIL di Python, sehingga lebih cocok untuk tugas-tugas yang terikat dengan I/O (seperti pembacaan/penulisan file atau permintaan jaringan).

Memulai dengan Modul Multiprosesor

Modul multiproses Python menyediakan berbagai cara untuk membuat dan mengelola banyak proses. Di bawah ini adalah beberapa konsep utama dan cara menggunakannya:

Mengimpor Modul

Untuk menggunakan multiproses, impor modul:

mengimpor multipemrosesan

Konsep Dasar Pemrosesan Ganda

Proses: Proses adalah sebuah contoh program yang independen. Dalam konteks Python, setiap proses memiliki ruang memori sendiri.
Pool: Pool memungkinkan Anda untuk mengelola beberapa proses dengan jumlah proses pekerja yang tetap.
Antrian: Antrian digunakan untuk komunikasi antar proses.
Kunci: Kunci digunakan untuk mencegah proses mengakses sumber daya bersama secara bersamaan.

Contoh 1: Membuat Proses Sederhana

Cara paling dasar untuk membuat proses adalah dengan menggunakan kelas Process. Berikut adalah contoh sederhana:

dari multiproses impor Proses Proses

def print_numbers():
 for i in range(5):
 print(f"Number: {i}")
 if __name__ == "__main__":
 # Create a Process
 process = Process(target=print_numbers)
 # Start the Process
 process.start()
 # Wait for the Process to complete
 process.join()
 print("Process completed.")

Proses: Kelas Proses digunakan untuk membuat proses baru.
target: Argumen target menentukan fungsi yang harus dijalankan oleh proses.
start(): Memulai proses.
join(): Menunggu proses selesai sebelum melanjutkan dengan kode selanjutnya.

Pada contoh ini, fungsi print_numbers akan berjalan pada proses yang terpisah, sehingga memungkinkan program utama untuk berjalan bersamaan.

Contoh 2: Menggunakan multiprocessing.Pool

Kelas Pool berguna ketika Anda ingin mengelola kumpulan proses pekerja dan menerapkan fungsi ke beberapa item data secara paralel. Berikut ini sebuah contoh:

dari multiproses impor Pool

def square_number(n):
return n * n

if __name__ == "__main__":
 # Create a Pool with 4 processes
 with Pool(4) as pool:
 numbers = [1, 2, 3, 4, 5]
 # Use pool.map() to apply the function to each item in the list
 results = pool.map(square_number, numbers)

print(f “Jumlah kuadrat: {hasil}”)

Pool: Membuat kumpulan proses pekerja. Dalam kasus ini, ini membuat 4 proses.
map(): Fungsi map mengambil sebuah fungsi dan sebuah iterable (seperti daftar) dan menerapkan fungsi tersebut ke setiap elemen secara paralel.

Contoh ini mengkuadratkan setiap angka dalam daftar angka menggunakan 4 proses paralel. Fungsi pool.map() membagi pekerjaan di antara proses-proses yang tersedia dan mengembalikan hasilnya dalam bentuk daftar.

Contoh 3: Menggunakan Antrian untuk Komunikasi Antar-Proses

Jika Anda membutuhkan proses untuk berkomunikasi atau berbagi data, Anda dapat menggunakan Queue. Hal ini sangat berguna ketika Anda memiliki skenario produsen-konsumen.

dari impor multiproses Proses, Antrian

def producer(queue):
 for i in range(5):
 queue.put(i)
 print(f"Produced: {i}")

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

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

# Create producer and consumer processes
 producer_process = Process(target=producer, args=(queue,))
 consumer_process = Process(target=consumer, args=(queue,))

# Start both processes
 producer_process.start()
 consumer_process.start()

# Wait for both processes to finish
 producer_process.join()
 consumer_process.join()

print(“Semua item telah diproses.”)

- Antrian: Antrean digunakan untuk melewatkan data antar proses.
- put(): Menambahkan sebuah item ke dalam antrian.
- get(): Mengambil item dari antrian.

Dalam contoh ini, produsen menambahkan item ke dalam antrean, sementara konsumen mengambil dan memproses item tersebut.