Python - Pemrograman Multithreaded

Halaman SebelumnyaHalaman Berikutnya

Menjalankan beberapa utas mirip dengan menjalankan beberapa program berbeda secara bersamaan, tetapi dengan manfaat berikut

Beberapa utas dalam suatu proses berbagi ruang data yang sama dengan utas utama dan oleh karena itu 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. Ini memiliki pointer instruksi yang melacak di mana dalam konteksnya saat ini sedang berjalan.

Itu dapat didahului (diinterupsi)
Ini dapat ditunda sementara (juga dikenal sebagai tidur) saat utas lainnya sedang berjalan - ini disebut menghasilkan.

Memulai Thread Baru

Untuk menelurkan utas lain, Anda perlu memanggil metode berikut yang tersedia di utas modul

thread.start_new_thread ( function, args[, kwargs] )

Panggilan metode ini memungkinkan cara yang cepat dan efisien untuk membuat utas baru di Linux dan Windows.

Pemanggilan metode segera kembali dan utas anak dimulai dan memanggil fungsi dengan daftar args . yang diteruskan . Saat fungsi kembali, utas berakhir.

Di sini, args adalah tupel argumen; gunakan Tuple kosong untuk memanggil fungsi tanpa memberikan argumen apa pun. kwargs adalah kamus opsional argumen kata kunci.

Contoh

#!/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

Ketika kode di atas dijalankan, menghasilkan hasil sebagai berikut

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 threading tingkat rendah, tetapi utas modul sangat terbatas dibandingkan dengan modul threading yang lebih baru.

The Threading Modul

Modul threading baru yang disertakan dengan Python 2.4 memberikan dukungan tingkat tinggi yang jauh lebih kuat untuk thread daripada modul thread yang dibahas di bagian sebelumnya.

mengutas modul memperlihatkan semua metode utas modul dan menyediakan beberapa metode tambahan

threading.activeCount() Mengembalikan jumlah objek thread yang aktif.
threading.currentThread() Mengembalikan jumlah objek utas dalam kontrol utas pemanggil.
threading.enumerate() Mengembalikan daftar semua objek utas yang sedang aktif.

Selain metode, modul threading memiliki Utas kelas yang mengimplementasikan threading. Metode yang disediakan oleh Utas kelas adalah sebagai berikut

lari() Metode run() adalah titik masuk untuk sebuah thread.
mulai() Metode start() memulai thread dengan memanggil metode run.
bergabung([waktu]) Join() menunggu thread berakhir.
isAlive() Metode isAlive() memeriksa apakah sebuah thread masih dieksekusi.
getName() Metode getName() mengembalikan nama thread.
setName() Metode setName() menetapkan nama thread.

Membuat Thread Menggunakan Threading Modul

Untuk mengimplementasikan thread baru menggunakan modul threading, Anda harus melakukan hal berikut −

Tentukan subkelas baru dari Utas kelas.
Ganti __init__(self [,args]) metode untuk menambahkan argumen tambahan.
Kemudian, ganti metode run(self [,args]) untuk mengimplementasikan apa yang harus dilakukan utas saat dimulai.

Setelah Anda membuat Utas . baru subkelas, Anda dapat membuat turunannya dan kemudian memulai utas baru dengan menjalankan start() , yang pada gilirannya memanggil run() metode.

Contoh

#!/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"

Ketika kode di atas dijalankan, menghasilkan hasil sebagai berikut

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 Utas

Modul threading yang disediakan dengan Python mencakup mekanisme penguncian sederhana yang memungkinkan Anda untuk menyinkronkan utas. Kunci baru dibuat dengan memanggil Lock() metode, yang mengembalikan kunci baru.

memperoleh(memblokir) metode objek kunci baru digunakan untuk memaksa utas berjalan secara sinkron. pemblokiran opsional parameter memungkinkan Anda untuk mengontrol apakah utas menunggu untuk mendapatkan kunci.

Jika memblokir diatur ke 0, utas segera kembali dengan nilai 0 jika kunci tidak dapat diperoleh dan dengan 1 jika kunci diperoleh. Jika pemblokiran disetel ke 1, utas akan memblokir dan menunggu kunci dilepaskan.

rilis() metode objek kunci baru digunakan untuk melepaskan kunci saat tidak lagi diperlukan.

Contoh

#!/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"

Ketika kode di atas dijalankan, menghasilkan 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

Antrian Prioritas Multithread

Antrian module memungkinkan Anda membuat objek antrian baru yang dapat menampung sejumlah item tertentu. Ada metode berikut untuk mengontrol Antrian

dapatkan() Get() menghapus dan mengembalikan item dari antrian.
menempatkan() Put menambahkan item ke antrian.
qsize() qsize() mengembalikan jumlah item yang sedang dalam antrian.
kosong() The empty() mengembalikan True jika antrian kosong; jika tidak, Salah.
penuh() full() mengembalikan True jika antrian penuh; jika tidak, Salah.

Contoh

#!/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

def process_data(threadName, q):
   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"

Ketika kode di atas dijalankan, menghasilkan hasil 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

Python - Mengirim Email menggunakan SMTP Python - Pemrosesan XML

Python