Python - Multithreading

Halo di sana, para penyihir Python masa depan! Hari ini, kita akan melakukan perjalanan yang menarik ke dunia multithreading di Python. Jangan khawatir jika anda baru lagi dengan pemrograman; saya akan menjadi pemandu anda yang ramah, dan kita akan menjelajahi topik ini langkah demi langkah. Jadi, ambilkan wands virtual anda (papan kekunci), dan mari kita melompat masuk!

Apa itu Multithreading?

Sebelum kita mulai untuk menjadikan penyihir dengan threads Python, mari kita fahami apa itu multithreading. Bayangkan anda adalah seorang chef di dapur yang sibuk. Jika anda memasak sendiri, anda hanya dapat melakukan satu tugas pada satu masa – untuk mengiris sayur, kemudian untuk mendidih air, kemudian untuk menggoreng daging. Tetapi apa jika anda memiliki beberapa tangan yang dapat melakukan tugas berbeda secara bersamaan? Itulah yang sebenarnya melakukan multithreading bagi program kita!

Multithreading membolehkan program untuk menjalankan beberapa tugas secara bersamaan di dalam satu proses. Ia seperti memiliki beberapa chef (threads) yang bekerja bersama-sama di atas dapur yang sama (proses) untuk mempersiapkan makanan yang sedap (output program) lebih cepat dan lebih efisien.

Perbandingan dengan Proses

Sekarang, anda mungkin bertanya-tanya, "Tapi guru, saya telah mendengar tentang proses juga. Bagaimana threads berbeda?" Pertanyaan yang bagus! Mari kita pecahkan itu:

Penggunaan Sumber: Threads seperti saudara kandung yang berbagi ruangan (ruang memori), sementara proses seperti tetangga dengan rumah terpisah. Threads adalah lebih ringan dan berbagi sumber, membuatnya lebih efisien untuk beberapa tugas.
Komunikasi: Threads dapat berbicara dengan mudah dengan cara berbagi variabel, tetapi proses perlu menggunakan telefon khusus (komunikasi antar-proses) untuk berbicara satu sama lain.
Overhead: Membuat dan mengurus threads biasanya lebih cepat dan memerlukan lebih sedikit sumber sistem dibandingkan dengan proses.
Kompleksitas: Walaupun threads dapat membuat program anda lebih cepat, mereka juga memasukkan kompleksitas. Itu seperti mengocok kelereng – menyenangkan dan efisien jika dilakukan dengan benar, tetapi anda mungkin akan menjatuhkan kelereng jika anda tidak berhati-hati!

Modul Pengurus Thread di Python

Python, sebagai bahasa yang derma, menyediakan kita dengan beberapa modul untuk bekerja dengan threads. Dua utama di antaranya adalah:

threading: Ini adalah antarmuka tingkat tinggi untuk bekerja dengan threads. Itu seperti pelatih penyihir yang ramah yang melakukan sebagian besar kerja berat bagi anda.
_thread: Ini adalah antarmuka tingkat rendah. Itu seperti buku sakit kuno – kuat tetapi memerlukan lebih banyak keahlian untuk digunakan dengan benar.

Untuk perjalanan penyihir kita hari ini, kita akan fokus pada modul threading, karena itu lebih ramah bagi pemula dan banyak digunakan.

Memulakan Thread Baru

Baiklah, mari kita jadikan penyihir pertama thread! Ini cara kita membuat dan memulakan thread baru:

import threading
import time

def cetak_nombor():
for i in range(5):
time.sleep(1)
print(f"Thread 1: {i}")

# Buat thread baru
thread1 = threading.Thread(target=cetak_nombor)

# Mulakan thread
thread1.start()

# Thread utama terus melakukan eksekusi
for i in range(5):
time.sleep(1)
print(f"Thread utama: {i}")

# Tunggu thread1 untuk selesai
thread1.join()

print("Semua selesai!")

Mari kita pecahkan incantasi penyihir ini:

Kita import modul threading dan time.
Kita define fungsi cetak_nombor() yang akan dieksekusi oleh thread kita.
Kita buat objek thread baru, menentukan fungsi yang harus dijalankan.
Kita mulakan thread menggunakan metode start().
Thread utama terus melakukan loopnya.
Kita gunakan join() untuk menunggu thread kita selesai sebelum mengakhiri program.

Apabila anda menjalankan ini, anda akan melihat nombor dari kedua-dua threads yang diinterleaved, menunjukkan eksekusi koncurrent!

Penyelarasan Thread

Sekarang, bayangkan bantuan chef kita cuba untuk menggunakan rakis yang sama pada saat yang sama – kacau, kan? Itulah di mana penyelarasan thread datang dalam pertembungan. Kita gunakan kunci untuk memastikan hanya satu thread yang dapat mengakses sumber yang dibagi pada satu masa.

Berikut adalah contoh:

import threading
import time

# Sumber yang dibagi
counter = 0
kunci = threading.Lock()

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

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

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

# Tunggu kedua-dua thread untuk selesai
thread1.join()
thread2.join()

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

Dalam contoh ini, kita gunakan kunci untuk memastikan hanya satu thread yang dapat menambah counter pada satu masa, mencegah kondisi lomba.

Antrian Prioritas Multithreaded

Terakhir tapi tidak terkecuali, mari kita lihat aplikasi praktikal multithreading – antrian prioritas. Bayangkan ruang penyakit darurat di atas rumah sakit di mana pasien diberi perhatian berdasarkan tingkat keganasan kondisinya, bukan hanya waktu kedatangan mereka.

import threading
import queue
import time
import random

# Buat antrian prioritas
task_queue = queue.PriorityQueue()

def pekerja():
while True:
prioritas, tugas = task_queue.get()
print(f"Memproses tugas: {tugas} (Prioritas: {prioritas})")
time.sleep(random.uniform(0.1, 0.5))  # Simulasikan kerja
task_queue.task_done()

# Buat dan mulakan thread pekerja
for _ in range(3):
thread = threading.Thread(target=pekerja, daemon=True)
thread.start()

# Tambah tugas ke antrian
for i in range(10):
prioritas = random.randint(1, 5)
tugas = f"Tugas {i}"
task_queue.put((prioritas, tugas))

# Tunggu semua tugas untuk selesai
task_queue.join()
print("Semua tugas selesai!")

Contoh ini menunjukkan bagaimana beberapa thread dapat bekerja bersama-sama untuk memproses tugas dari antrian prioritas dengan efisiensi.

Kesimpulan

Tahniah, para Pythonistas muda! Anda baru saja melakukan langkah pertama anda ke wilayah penyihir multithreading. Ingat, dengan kekuatan besar datang tanggung jawab besar – gunakan threads dengan bijak, dan mereka akan membuat program anda lebih cepat dan lebih efisien.

Berikut adalah rakitan singkat atas metod thread utama yang kita telah pelajari:

Metod	Keterangan
`Thread(target=function)`	Membuat thread baru untuk menjalankan fungsi yang ditentukan
`start()`	Memulakan aktiviti thread
`join()`	Menunggu thread untuk selesai
`Lock()`	Membuat kunci untuk penyelarasan thread
`acquire()`	Mengambil kunci
`release()`	Menglepaskan kunci

Teruskan untuk berlatih, tetap curious, dan tidak lama lagi anda akan mengatur thread seperti seorang maestro Python yang sebenar! Selamat coding!

Credits: Image by storyset

Tutorial Sebelumnya:

Python - Penyebut terbina dalaman

Tutorial Seterusnya:

Python - Kitaran Kehidupan Thread