Multi Process #
Multiprocessing adalah teknik untuk menjalankan beberapa proses secara bersamaan dalam satu program, yang berguna untuk memanfaatkan kemampuan CPU multi-core. Modul multiprocessing di Python memungkinkan Anda membuat dan mengelola proses dengan cara yang mirip dengan modul threading. Berikut adalah penjelasan mendetail tentang multiprocessing di Python beserta contoh penggunaannya.
Modul multiprocessing
#
Modul multiprocessing menyediakan berbagai kelas dan fungsi untuk membuat dan mengelola proses.
Kelas dan Fungsi Utama dalam multiprocessing:
multiprocessing.Process: Kelas utama untuk membuat dan mengelola proses.multiprocessing.Pool: Kelas untuk membuat pool proses yang dapat digunakan untuk menjalankan fungsi secara paralel.multiprocessing.Queue: Kelas untuk berbagi data antara proses menggunakan antrian.multiprocessing.Pipe: Kelas untuk komunikasi antara proses menggunakan pipa.multiprocessing.Lock: Kelas untuk mengelola kunci (lock) yang digunakan untuk menghindari kondisi balapan (race condition).
Membuat Proses #
Anda bisa membuat proses di Python dengan dua cara utama:
- Membuat subkelas dari
multiprocessing.Processdan menimpa metoderun. - Membuat instance
Processdengan target fungsi.
Kelas #
import multiprocessing
import time
class MyProcess(multiprocessing.Process):
def __init__(self, name):
multiprocessing.Process.__init__(self)
self.name = name
def run(self):
print(f"Process {self.name} starting")
time.sleep(2)
print(f"Process {self.name} finishing")
# Membuat dan memulai proses
process1 = MyProcess("A")
process2 = MyProcess("B")
process1.start()
process2.start()
process1.join()
process2.join()
print("All processes finished")
Fungsi #
import multiprocessing
import time
def print_hello(name):
print(f"Process {name} starting")
time.sleep(2)
print(f"Process {name} finishing")
# Membuat dan memulai proses
process1 = multiprocessing.Process(target=print_hello, args=("A",))
process2 = multiprocessing.Process(target=print_hello, args=("B",))
process1.start()
process2.start()
process1.join()
process2.join()
print("All processes finished")
Paralelisme #
multiprocessing.Pool menyediakan cara yang lebih mudah untuk menjalankan fungsi secara paralel.
Pool
#
import multiprocessing
import time
def square(x):
return x * x
# Membuat pool proses
with multiprocessing.Pool(processes=4) as pool:
results = pool.map(square, [1, 2, 3, 4, 5])
print(results) # Output: [1, 4, 9, 16, 25]
Queue
#
multiprocessing.Queue digunakan untuk berbagi data antara proses.
Penggunaan Queue
#
import multiprocessing
import time
def worker(queue):
while not queue.empty():
item = queue.get()
print(f"Process {multiprocessing.current_process().name} got item: {item}")
time.sleep(1)
# Membuat antrian dan menambahkan data
queue = multiprocessing.Queue()
for item in range(5):
queue.put(item)
# Membuat dan memulai proses
processes = []
for _ in range(2):
process = multiprocessing.Process(target=worker, args=(queue,))
processes.append(process)
process.start()
for process in processes:
process.join()
print("All processes finished")
Pipe
#
multiprocessing.Pipe menyediakan cara untuk komunikasi dua arah antara proses.
Penggunaan Pipe
#
import multiprocessing
def sender(pipe):
pipe.send("Hello from sender")
response = pipe.recv()
print(f"Sender received: {response}")
def receiver(pipe):
message = pipe.recv()
print(f"Receiver got message: {message}")
pipe.send("Hello from receiver")
# Membuat pipe
parent_conn, child_conn = multiprocessing.Pipe()
# Membuat dan memulai proses
process1 = multiprocessing.Process(target=sender, args=(parent_conn,))
process2 = multiprocessing.Process(target=receiver, args=(child_conn,))
process1.start()
process2.start()
process1.join()
process2.join()
print("All processes finished")
Race Condition #
multiprocessing.Lock digunakan untuk mengelola akses ke sumber daya yang dibagikan untuk menghindari kondisi balapan.
Penggunaan Lock
#
import multiprocessing
import time
class Counter:
def __init__(self):
self.value = 0
self._lock = multiprocessing.Lock()
def increment(self):
with self._lock:
self.value += 1
counter = Counter()
def increment_counter(counter):
for _ in range(100000):
counter.increment()
process1 = multiprocessing.Process(target=increment_counter, args=(counter,))
process2 = multiprocessing.Process(target=increment_counter, args=(counter,))
process1.start()
process2.start()
process1.join()
process2.join()
print(f"Final counter value: {counter.value}")
Manager
#
multiprocessing.Manager menyediakan cara untuk membuat objek yang dapat dibagi antar proses, seperti list dan dictionary.
Penggunaan Manager
#
import multiprocessing
def worker(shared_list, shared_dict, lock):
with lock:
shared_list.append(multiprocessing.current_process().name)
shared_dict[multiprocessing.current_process().name] = len(shared_list)
if __name__ == '__main__':
with multiprocessing.Manager() as manager:
shared_list = manager.list()
shared_dict = manager.dict()
lock = manager.Lock()
processes = []
for _ in range(4):
process = multiprocessing.Process(target=worker, args=(shared_list, shared_dict, lock))
processes.append(process)
process.start()
for process in processes:
process.join()
print(shared_list) # Output: [Nama proses 1, Nama proses 2, ...]
print(shared_dict) # Output: {Nama proses 1: 1, Nama proses 2: 2, ...}
Kesimpulan #
Multiprocessing di Python memungkinkan Anda menjalankan beberapa operasi secara paralel dalam proses yang berbeda, yang sangat berguna untuk tugas-tugas CPU-bound. Dengan menggunakan modul multiprocessing, Anda dapat membuat dan mengelola proses dengan cara yang mirip dengan threading, tetapi dengan keuntungan bahwa setiap proses berjalan dalam memori terpisah, menghindari Global Interpreter Lock (GIL) yang ada di threading.
Dengan contoh-contoh di atas, Anda dapat mulai mengimplementasikan multiprocessing dalam aplikasi Python Anda untuk meningkatkan efisiensi dan performa.