Last Updated on September 22, 2022 by
Halo pembaca setia codekey.id! Sudah berapa lama Anda belajar Pyhton dan menggunakannya untuk membuat aplikasi? Bahasa pemrograman Python bukanlah hal yang asing karena sangat sering digunakan. Bagi Anda yang mulai tertarik lebih jauh belajar Python, maka Python multithread atau yang biasa disebut juga dengan threading ini, wajib Anda pelajari.
Kita ketahui bersama bahwa Pyton memiliki satu kelemahan yaitu dalam pemrosesan data. Namun dengan menggunakan threading Anda dapat mengatasi masalah satu ini. Kali ini kami akan membahas berbagai hal yang harus Anda ketahui tentang Python Multithread. Berikut sub materinya:
- Kelebihan Python Multithread
- Memulai Thread Baru
- Modul untuk Python Multithread
- Membuat Thread Dengan Modul Multithread
- Menyinkronkan Thread
- Python Multithread: Antrian Prioritas
Table of Contents
Kelebihan Python Multithread
Sebelum membahas kelebihan teknik Multithread pada bahasa Python, mari kita bahas pengertiannya terlebih dahulu. Teknik Multithread pada bahasa Python adalah teknik yang digunakan untuk nenjalankan beberapa threads yang mirip dengan menjalankan beberapa program berbeda secara bersamaan. Di mana manfaat menggunakan tetapi dengan manfaat berikut
- Beberapa utas dalam suatu proses berbagi ruang data yang sama dengan utas utama dan karenanya dapat berbagi informasi atau berkomunikasi satu sama lain dengan lebih mudah daripada jika mereka adalah proses yang terpisah.
- Utas terkadang disebut proses ringan dan tidak memerlukan banyak memori di atas kepala; mereka lebih murah daripada proses.
Sebuah thread memiliki awal, urutan eksekusi, dan kesimpulan. Di dalam thread memiliki pointer instruksi yang melacak di mana dalam sebuah konteksnya sedang berjalan saat ini. Berikut poin-poinnya
- Thread dapat didahului (terganggu)
- Thread dapat ditunda sementara (juga dikenal sebagai sleeping) sementara utas lainnya sedang berjalan – ini disebut yielding atau menghasilkan.
Memulai Thread Baru
Untuk mulai membuat sebuah sebuah threading atau utas lain, Anda dapat menggunakan metode berikut ini, perhatikan code berikut:
thread.start_new_thread ( function, args[, kwargs] )
Dengan menggunakan coding di atas, ini memungkinkan Anda untuk menggunakan cara yang cepat dan efesien untuk membuat sebuah thread. Cara ini dapat Anda terapkan baik dengan menggunakan Linux maupun Windows.
Pemanggilan metode dengan pengembalian segera dan thread baru dimulai serta memanggil fungsi dengan daftar args yang diteruskan. Ketika fungsi kembali, thread yang dijalankan akan berakhir.
Di sini, args adalah tupel argumen; di mana penggunaan Tuple kosong ialah untuk memanggil fungsi tanpa memberikan argumen apa pun. kwargs adalah kamus opsional pada argumen kata kunci.
Agar lebih memahaminya, perhatikan contoh berikut ini:
#!/usr/bin/python
import thread
import time
# Define a function for the thread
def print_time( threadName, delay):
count = 0
while count < 5:
time.sleep(delay)
count += 1
print "%s: %s" % ( threadName, time.ctime(time.time()) )
# Create two threads as follows
try:
thread.start_new_thread( print_time, ("Thread-1", 2, ) )
thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
print "Error: unable to start thread"
while 1:
pass
Setelah Anda menjalankan coding di atas, berikut ini output yang akan Anda dapatkan:
Thread-1: Thu Jan 22 15:42:17 2009 Thread-1: Thu Jan 22 15:42:19 2009 Thread-2: Thu Jan 22 15:42:19 2009 Thread-1: Thu Jan 22 15:42:21 2009 Thread-2: Thu Jan 22 15:42:23 2009 Thread-1: Thu Jan 22 15:42:23 2009 Thread-1: Thu Jan 22 15:42:25 2009 Thread-2: Thu Jan 22 15:42:27 2009 Thread-2: Thu Jan 22 15:42:31 2009 Thread-2: Thu Jan 22 15:42:35 2009
Meskipun sangat efektif untuk melakukan Python Multithread atau threading tingkat rendah, namun modul thread ini sangat terbatas jika dibandingkan dengan modul threading yang lebih baru.
Modul untuk Python Multithread
Modul threading yang lebih baru yang disertakan dengan Python 2.4 yang memberikan dukungan tingkat tinggi. Sehingga modul baru ini jauh lebih kuat untuk melakukan threading daripada modul thread yang telah kita bahas pada bagian sebelumnya.
Modul threading ini memperlihatkan semua metode modul thread dan menyediakan beberapa metode tambahan. Berikut ini metode tambahan yang ada dan fungsinya:
- activeCount() Berfungsi untuk mengembalikan jumlah objek thread yang aktif.
- currentThread() Memiliki fungsi untuk mengembalikan jumlah objek thread dalam kontrol thread pemanggil.
- enumerate() Berfungsi mengembalikan daftar semua objek thread yang sedang aktif.
Selain metode, modul threading terbaru ini memiliki kelas Thread yang mengimplementasikan threading. Metode yang disediakan oleh kelas Thread ialah sebagai berikut:
- run() Metode run() merupakan titik masuk untuk sebuah thread.
- start() Metode start() berfungsi memulai thread dengan memanggil metode run.
- join([time]) Join() berfungsi untuk menunggu thread berakhir.
- isAlive() Metode isAlive() akan memeriksa apakah sebuah thread masih dieksekusi atau tidak.
- getName() Metode getName() ini dapat digunakan mengembalikan nama thread.
- setName() Metode setName() akan menetapkan nama sebuah thread.
Membuat Thread Dengan Modul Multithread
Untuk mengimplementasikan sebuah threadi baru menggunakan modul threading, Anda harus melakukan beberapa langkah berikut ini:
- Menentukan subclass baru dari kelas Thread yang ada.
- Mengganti metode __init__(self [,args]) untuk menambahkan argumen tambahan.
- Hal terakhir ialah mengganti metode run(self [,args]) untuk mengimplementasikan apa yang harus dilakukan thread saat dimulai.
Setelah Anda membuat subkelas Thread baru, Anda dapat membuat turunannya dan kemudian memulai thread baru dengan memanggil start(), yang pada gilirannya nanti akan memanggil metode run().
Agar lebih jelas, perhatikan contoh pembuatan thread di bawah ini:
#!/usr/bin/python
import threading
import time
exitFlag = 0
class myThread (threading.Thread):
def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
def run(self):
print "Starting " + self.name
print_time(self.name, 5, self.counter)
print "Exiting " + self.name
def print_time(threadName, counter, delay):
while counter:
if exitFlag:
threadName.exit()
time.sleep(delay)
print "%s: %s" % (threadName, time.ctime(time.time()))
counter -= 1
# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
# Start new Threads
thread1.start()
thread2.start()
print "Exiting Main Thread"
Jika Anda telah membuat dengan benar, maka akan muncul output seperti di bawah ini:
Starting Thread-1 Starting Thread-2 Exiting Main Thread Thread-1: Thu Mar 21 09:10:03 2013 Thread-1: Thu Mar 21 09:10:04 2013 Thread-2: Thu Mar 21 09:10:04 2013 Thread-1: Thu Mar 21 09:10:05 2013 Thread-1: Thu Mar 21 09:10:06 2013 Thread-2: Thu Mar 21 09:10:06 2013 Thread-1: Thu Mar 21 09:10:07 2013 Exiting Thread-1 Thread-2: Thu Mar 21 09:10:08 2013 Thread-2: Thu Mar 21 09:10:10 2013 Thread-2: Thu Mar 21 09:10:12 2013 Exiting Thread-2
Menyinkronkan Thread
Pada modul threading yang telah disediakan oleh Python, di dalamnya mencakup mekanisme penguncian sederhana yang memungkinkan Anda untuk menyinkronkan thread yang ada. Kunci baru akan dibuat dengan memanggil metode Lock(), di mana metode ini yang akan mengembalikan kunci baru.
Metode acquire(blocking) dari objek kunci baru digunakan untuk memaksa threads berjalan secara sinkron. Parameter blocking opsional ini akan memungkinkan Anda untuk mengontrol apakah threads akan menunggu untuk mendapatkan kunci.
Jika blocking diatur ke 0, threads akan segera kembali dengan nilai 0 jika kunci tidak dapat diperoleh dan dengan 1 jika kunci diperoleh. Jika pemblokiran diatur ke 1, threads akan memblokir dan menunggu kunci untuk dilepaskan.
Metode release() dari objek kunci baru digunakan untuk melepaskan kunci ketika tidak lagi diperlukan. Berikut ini contoh penerapannya:
#!/usr/bin/python
import threading
import time
class myThread (threading.Thread):
def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
def run(self):
print "Starting " + self.name
# Get lock to synchronize threads
threadLock.acquire()
print_time(self.name, self.counter, 3)
# Free lock to release next thread
threadLock.release()
def print_time(threadName, delay, counter):
while counter:
time.sleep(delay)
print "%s: %s" % (threadName, time.ctime(time.time()))
counter -= 1
threadLock = threading.Lock()
threads = []
# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
# Start new Threads
thread1.start()
thread2.start()
# Add threads to thread list
threads.append(thread1)
threads.append(thread2)
# Wait for all threads to complete
for t in threads:
t.join()
print "Exiting Main Thread"
Setelah menjalankan coding di atas, jika code-code yang dimasukkan benar, maka Anda akan mendapatkan hasil sebagai berikut:
Starting Thread-1 Starting Thread-2 Thread-1: Thu Mar 21 09:11:28 2013 Thread-1: Thu Mar 21 09:11:29 2013 Thread-1: Thu Mar 21 09:11:30 2013 Thread-2: Thu Mar 21 09:11:32 2013 Thread-2: Thu Mar 21 09:11:34 2013 Thread-2: Thu Mar 21 09:11:36 2013 Exiting Main Thread
Python Multithread : Antrian Prioritas
Modul Queue atau antrian akan memungkinkan Anda untuk membuat objek antrian baru yang dapat menampung sejumlah item tertentu. Di bawah ini merupakan metode yang dapat Anda gunakan untuk mengontrol antrian Multithread:
- get()Get() berfungsi untuk menghapus dan mengembalikan item dari antrian.
- put() Put berfungsi menambahkan item ke antrian.
- qsize() qsize() digunakan untuk mengembalikan jumlah item yang sedang dalam antrian.
- kosong() Kosong() berfungsi mengembalikan True jika antrian kosong; jika tidak, maka hasilnya ialah false.
- full() the full() digunakan untuk mengembalikan True jika antrian penuh; jika tidak, output yang ditampilkan adalah false.
Perhatikan contoh penerapannya pada coding di bawah ini:
#!/usr/bin/python
import Queue
import threading
import time
exitFlag = 0
class myThread (threading.Thread):
def __init__(self, threadID, name, q):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.q = q
def run(self):
print "Starting " + self.name
process_data(self.name, self.q)
print "Exiting " + self.name
while not exitFlag:
queueLock.acquire()
if not workQueue.empty():
data = q.get()
queueLock.release()
print "%s processing %s" % (threadName, data)
else:
queueLock.release()
time.sleep(1)
threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = Queue.Queue(10)
threads = []
threadID = 1
# Create new threads
for tName in threadList:
thread = myThread(threadID, tName, workQueue)
thread.start()
threads.append(thread)
threadID += 1
# Fill the queue
queueLock.acquire()
for word in nameList:
workQueue.put(word)
queueLock.release()
# Wait for queue to empty
while not workQueue.empty():
pass
# Notify threads it's time to exit
exitFlag = 1
# Wait for all threads to complete
for t in threads:
t.join()
print "Exiting Main Thread"
Jika coding yang dibuat benar, maka Anda akan mendapatkan output sebagai berikut:
Starting Thread-1 Starting Thread-2 Starting Thread-3 Thread-1 processing One Thread-2 processing Two Thread-3 processing Three Thread-1 processing Four Thread-2 processing Five Exiting Thread-3 Exiting Thread-1 Exiting Thread-2 Exiting Main Thread
Nah itulah tadi pembahasan menarik dari Codekey.id tentang Python Multithread atau threading khusus untuk Anda. Apakah Anda dapat memahami dengan baik? Jika Anda menyukai artikel ini, jangan lupa untuk membaca berbagai artikel menarik tentang berbagai bahasa pemrograman hanya di codekey.id ! sekian artikel kali ini, jangan lupa untuk terus berlatih!
Jasa Pembuatan Aplikasi, Website dan Internet Marketing | PT APPKEY
PT APPKEY adalah perusahaan IT yang khusus membuat aplikasi Android, iOS dan mengembangkan sistem website. Kami juga memiliki pengetahuan dan wawasan dalam menjalankan pemasaran online sehingga diharapkan dapat membantu menyelesaikan permasalahan Anda.
