Multi Threading #

Multithreading adalah teknik untuk meningkatkan kinerja aplikasi dengan menjalankan beberapa thread secara bersamaan. Dalam Python, modul threading digunakan untuk mengimplementasikan multithreading. Berikut adalah penjelasan mendetail tentang multithreading di Python beserta contoh penggunaannya.

Apa itu Thread? #

Thread adalah unit eksekusi terkecil yang dapat dikelola oleh sistem operasi. Dalam konteks multithreading, beberapa thread dapat berjalan secara konkuren dalam satu proses, memungkinkan aplikasi untuk melakukan lebih dari satu tugas pada waktu yang bersamaan.

Modul threading #

Modul threading di Python menyediakan berbagai kelas dan fungsi untuk membuat dan mengelola thread.

Kelas dan Fungsi Utama dalam modul threading:

1. threading.Thread: Kelas utama untuk membuat dan mengelola thread.
2. threading.Lock: Kelas untuk mengelola kunci (lock) yang digunakan untuk menghindari kondisi balapan (race condition).
3. threading.Event: Kelas untuk mengelola sinyal antara thread.
4. threading.Semaphore: Kelas untuk mengelola batasan akses ke sumber daya.

Membuat Thread #

Anda bisa membuat thread di Python dengan dua cara utama:

1. Membuat subkelas dari threading.Thread dan menimpa metode run.
2. Membuat instance Thread dengan target fungsi.

Kelas #

import threading
import time

class MyThread(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name

    def run(self):
        print(f"Thread {self.name} starting")
        time.sleep(2)
        print(f"Thread {self.name} finishing")

# Membuat dan memulai thread
thread1 = MyThread("A")
thread2 = MyThread("B")

thread1.start()
thread2.start()

thread1.join()
thread2.join()

print("All threads finished")

Fungsi #

import threading
import time

def print_hello(name):
    print(f"Thread {name} starting")
    time.sleep(2)
    print(f"Thread {name} finishing")

# Membuat dan memulai thread
thread1 = threading.Thread(target=print_hello, args=("A",))
thread2 = threading.Thread(target=print_hello, args=("B",))

thread1.start()
thread2.start()

thread1.join()
thread2.join()

print("All threads finished")

Race Condition #

Race Condition terjadi ketika dua thread atau lebih mencoba mengakses dan memodifikasi data bersama secara bersamaan. Untuk menghindari ini, Anda dapat menggunakan threading.Lock.

Penggunaan Lock #

import threading
import time

class Counter:
    def __init__(self):
        self.value = 0
        self._lock = threading.Lock()

    def increment(self):
        with self._lock:
            self.value += 1

counter = Counter()

def increment_counter():
    for _ in range(100000):
        counter.increment()

thread1 = threading.Thread(target=increment_counter)
thread2 = threading.Thread(target=increment_counter)

thread1.start()
thread2.start()

thread1.join()
thread2.join()

print(f"Final counter value: {counter.value}")

Komunikasi Antar Thread #

threading.Event adalah cara untuk mengirim sinyal antar thread. Event memiliki metode set, clear, dan wait.

Penggunaan Event #

import threading
import time

event = threading.Event()

def wait_for_event():
    print("Thread waiting for event")
    event.wait()
    print("Thread received event")

thread = threading.Thread(target=wait_for_event)
thread.start()

time.sleep(2)
print("Main thread setting event")
event.set()

thread.join()

Semaphore #

threading.Semaphore digunakan untuk mengelola akses ke sumber daya yang terbatas.

Penggunaan Semaphore #

import threading
import time

sem = threading.Semaphore(2)

def access_resource(name):
    with sem:
        print(f"Thread {name} accessing resource")
        time.sleep(2)
        print(f"Thread {name} finished")

threads = []
for i in range(4):
    thread = threading.Thread(target=access_resource, args=(f"Thread-{i}",))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print("All threads finished")

ThreadPoolExecutor #

Untuk manajemen thread yang lebih mudah, Anda dapat menggunakan ThreadPoolExecutor dari modul concurrent.futures.

Penggunaan ThreadPoolExecutor #

from concurrent.futures import ThreadPoolExecutor
import time

def print_hello(name):
    print(f"Thread {name} starting")
    time.sleep(2)
    print(f"Thread {name} finishing")

with ThreadPoolExecutor(max_workers=2) as executor:
    futures = [executor.submit(print_hello, f"Thread-{i}") for i in range(4)]

    for future in futures:
        future.result()

print("All threads finished")

Kesimpulan #

Multithreading di Python memungkinkan Anda menjalankan beberapa operasi secara bersamaan, yang sangat berguna untuk tugas-tugas yang menghabiskan waktu seperti IO atau operasi jaringan. Namun, karena Python Global Interpreter Lock (GIL), multithreading di Python tidak selalu memberikan keuntungan performa pada tugas-tugas CPU-bound. Untuk tugas CPU-bound, Anda mungkin ingin mempertimbangkan multiprocessing.

Dengan contoh-contoh di atas, Anda dapat mulai mengimplementasikan multithreading dalam aplikasi Python Anda untuk meningkatkan efisiensi dan performa.