Python - Synchronizing Threads (Indonesia)

Halo para jago Python masa depan! Hari ini, kita akan memulai perjalanan yang menarik ke dunia sinkronisasi thread. Bayangkan Anda sebagai seorang konduktor orkestra tempat setiap musisi adalah sebuah thread, dan Anda harus memastikan mereka semua untuk bermain secara bersamaan. Itu hampir saja apa itu sinkronisasi thread dalam pemrograman!

Python - Synchronizing Threads

Sinkronisasi Thread menggunakan Kunci (Locks)

Mari kita mulai dengan alat paling dasar dalam toolkit sinkronisasi kita: kunci (locks). Pernahkan Anda bayangkan kunci seperti sebuah tanda "jangan ganggu" di atas pintu kamar hotel. Ketika sebuah thread mengambil kunci, itu seperti menempatkan tanda itu, memberitahu thread lain, "Hai, saya sibuk di sini!"

Berikut adalah contoh sederhana untuk menggambarkan konsep ini:

import threading
import time

# Sumber daya bersama
counter = 0

# Buat sebuah kunci
lock = threading.Lock()

def increment():
global counter
for _ in range(100000):
lock.acquire()
counter += 1
lock.release()

# Buat dua thread
thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)

# Mulai thread
thread1.start()
thread2.start()

# Tunggu thread selesai
thread1.join()
thread2.join()

print(f"Nilai counter akhir: {counter}")

Dalam contoh ini, kita memiliki sumber daya bersama counter yang dua thread mencoba untuk menginkremen. Tanpa kunci, kita mungkin akan mendapatkan kondisi lomba, tempat kedua thread mencoba untuk menginkremen counter secara bersamaan, yang dapat mengarah ke hasil yang salah.

Dengan menggunakan lock.acquire() sebelum mengubah counter dan lock.release() setelahnya, kita memastikan bahwa hanya satu thread yang dapat menginkremen counter pada suatu waktu. Itu seperti melempar tong di atas lomba relay – hanya thread yang menjaga tong (kunci) yang dapat berlari (ubah sumber daya bersama).

Objek Kondisi untuk Sinkronisasi Thread Python

Sekarang, mari naikkan tingkat permainan sinkronisasi kita dengan Objek Kondisi. Ini seperti lampu lalu lintas yang canggih bagi thread kita, memungkinkan koordinasi yang lebih kompleks.

Berikut adalah contoh skenario produsen-konsumen menggunakan Objek Kondisi:

import threading
import time
import random

# Penyangga bersama
buffer = []
MAX_SIZE = 5

# Buat sebuah objek kondisi
condition = threading.Condition()

def producer():
global buffer
while True:
with condition:
while len(buffer) == MAX_SIZE:
print("Penyangga penuh, produsen menunggu...")
condition.wait()
item = random.randint(1, 100)
buffer.append(item)
print(f"Dihasilkan: {item}")
condition.notify()
time.sleep(random.random())

def consumer():
global buffer
while True:
with condition:
while len(buffer) == 0:
print("Penyangga kosong, konsumen menunggu...")
condition.wait()
item = buffer.pop(0)
print(f"Dikonsumsi: {item}")
condition.notify()
time.sleep(random.random())

# Buat thread produsen dan konsumen
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)

# Mulai thread
producer_thread.start()
consumer_thread.start()

# Biarkan berjalan untuk beberapa saat
time.sleep(10)

Dalam contoh ini, kita memiliki produsen menambahkan item ke penyangga dan konsumen menghapus item dari itu. Objek Kondisi membantu mengkoordinasikan tindakan mereka:

Produsen menunggu ketika penyangga penuh.
Konsumen menunggu ketika penyangga kosong.
Mereka memberi tahu satu sama lain saat aman untuk melanjutkan.

Itu seperti tarian yang terchoreografi dengan baik, dengan Objek Kondisi sebagai choreographer!

Sinkronisasi Thread menggunakan Metode join()

Metode join() seperti memberitahu satu thread untuk menunggu thread lain selesai pertunjukan mereka sebelum naik panggung. Ini adalah cara sederhana namun kuat untuk sinkronisasi thread.

Berikut adalah contoh:

import threading
import time

def worker(name, delay):
print(f"{name} dimulai...")
time.sleep(delay)
print(f"{name} selesai!")

# Buat thread
thread1 = threading.Thread(target=worker, args=("Thread 1", 2))
thread2 = threading.Thread(target=worker, args=("Thread 2", 4))

# Mulai thread
thread1.start()
thread2.start()

# Tunggu thread1 selesai
thread1.join()
print("Thread utama menunggu setelah thread1")

# Tunggu thread2 selesai
thread2.join()
print("Thread utama menunggu setelah thread2")

print("Semua thread telah selesai!")

Dalam contoh ini, thread utama memulai dua thread pekerja dan kemudian menunggu masing-masing untuk selesai menggunakan join(). Itu seperti seorang orang tua menunggu anak mereka untuk selesai mengerjakan PR mereka sebelum menyajikan makan malam!

Primitif Sinkronisasi Tambahan

Python menawarkan beberapa alat lain untuk sinkronisasi thread. Mari kita lihat beberapa diantaranya:

Primitif	Deskripsi	kasus Penggunaan
Semaphore	Memungkinkan jumlah thread terbatas mengakses sumber daya	Mengelola kolam koneksi database
Event	Memungkinkan satu thread untuk memberi tanda even kepada thread lain	Memberi tahu bahwa tugas telah selesai
Barrier	Memungkinkan beberapa thread menunggu sampai semua mencapai titik tertentu	Mensinkronkan mulai lomba

Berikut adalah contoh cepat menggunakan Semaphore:

import threading
import time

# Buat sebuah semaphore yang memungkinkan 2 thread pada suatu waktu
semaphore = threading.Semaphore(2)

def worker(name):
with semaphore:
print(f"{name} mengambil semaphore")
time.sleep(1)
print(f"{name} melepaskan semaphore")

# Buat dan mulai 5 thread
threads = []
for i in range(5):
thread = threading.Thread(target=worker, args=(f"Thread {i}",))
threads.append(thread)
thread.start()

# Tunggu semua thread selesai
for thread in threads:
thread.join()

print("Semua thread telah selesai!")

Dalam contoh ini, semaphore bertindak seperti sekuriti di klub, hanya memungkinkan dua thread masuk pada suatu waktu. Ini sempurna untuk situasi di mana Anda perlu membatasi akses ke sumber daya yang jarang.

Dan itu untuk saat ini, folks! Kita telah menjelajahi dunia yang menarik sinkronisasi thread di Python. Ingat, seperti mengkonduksi orkestra atau mengchoreografi tarian, sinkronisasi thread adalah semua tentang koordinasi dan waktu. Dengan alat ini di toolkit pemrograman Anda, Anda sudah di jalan untuk membuat program Python multi-threaded yang harmonis. Tetap berlatih, jangan ketinggalan rasa ingin tahu, dan happy coding!

Credits: Image by storyset

Tutorial Sebelumnya:

Python - Thread Daemon

Tutorial Selanjutnya:

Python - Komunikasi antar Thread