Python - Programmeren met meerdere threads

Vorige paginaVolgende pagina

Het uitvoeren van meerdere threads is vergelijkbaar met het gelijktijdig uitvoeren van verschillende programma's, maar met de volgende voordelen −

Meerdere threads binnen een proces delen dezelfde gegevensruimte met de hoofdthread en kunnen daarom gemakkelijker informatie delen of met elkaar communiceren dan wanneer het afzonderlijke processen waren.
Threads worden soms lichtgewicht processen genoemd en vereisen niet veel geheugenoverhead; ze zijn goedkoper dan processen.

Een thread heeft een begin, een uitvoeringsvolgorde en een conclusie. Het heeft een instructieaanwijzer die bijhoudt waar het in zijn context momenteel wordt uitgevoerd.

Het kan vooraf worden geleegd (onderbroken)
Het kan tijdelijk in de wacht worden gezet (ook bekend als slapen) terwijl andere threads actief zijn - dit wordt meegevend genoemd.

Een nieuwe thread starten

Om een andere thread te spawnen, moet je de volgende methode aanroepen die beschikbaar is in thread module −

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

Deze methodeaanroep zorgt voor een snelle en efficiënte manier om nieuwe threads te maken in zowel Linux als Windows.

De methodeaanroep keert onmiddellijk terug en de onderliggende thread start en roept de functie aan met de doorgegeven lijst van args . Wanneer de functie terugkeert, wordt de thread beëindigd.

Hier, argumenten is een tupel van argumenten; gebruik een lege tuple om de functie aan te roepen zonder argumenten door te geven. kwargs is een optioneel woordenboek van trefwoordargumenten.

Voorbeeld

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

Wanneer de bovenstaande code wordt uitgevoerd, levert dit het volgende resultaat op −

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

Hoewel het zeer effectief is voor threading op laag niveau, maar de thread module is zeer beperkt in vergelijking met de nieuwere threading-module.

De Threading Module

De nieuwere threading-module die bij Python 2.4 wordt geleverd, biedt veel krachtigere ondersteuning op hoog niveau voor threads dan de thread-module die in de vorige sectie is besproken.

De threading module onthult alle methoden van de thread module en biedt enkele aanvullende methoden −

threading.activeCount() − Retourneert het aantal thread-objecten dat actief is.
threading.currentThread() − Retourneert het aantal thread-objecten in de thread-besturing van de beller.
threading.enumerate() − Retourneert een lijst van alle thread-objecten die momenteel actief zijn.

Naast de methoden heeft de threading-module de Thread klasse die threading implementeert. De methoden die worden geboden door de Thread klasse zijn als volgt −

uitvoeren() − De methode run() is het startpunt voor een thread.
start() − De methode start() start een thread door de methode run aan te roepen.
doe mee([tijd]) − De join() wacht op het beëindigen van threads.
isAlive() − De methode isAlive() controleert of een thread nog steeds wordt uitgevoerd.
getName() − De methode getName() retourneert de naam van een thread.
setName() − De setName() methode stelt de naam van een thread in.

Thread maken met Threading Module

Om een nieuwe thread te implementeren met behulp van de threading-module, moet u het volgende doen −

Definieer een nieuwe subklasse van de Thread klasse.
Overschrijf de __init__(self [,args]) methode om extra argumenten toe te voegen.
Overschrijf vervolgens de methode run(self [,args]) om te implementeren wat de thread moet doen wanneer deze wordt gestart.

Nadat u de nieuwe Thread . heeft gemaakt subklasse, kunt u er een instantie van maken en vervolgens een nieuwe thread starten door de start() aan te roepen , die op zijn beurt run() . aanroept methode.

Voorbeeld

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

Wanneer de bovenstaande code wordt uitgevoerd, levert dit het volgende resultaat op −

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

Draden synchroniseren

De threading-module die bij Python wordt geleverd, bevat een eenvoudig te implementeren vergrendelingsmechanisme waarmee u threads kunt synchroniseren. Een nieuw slot wordt gemaakt door de Lock() . aan te roepen methode, die het nieuwe slot retourneert.

De acquire(blocking) methode van het nieuwe lock-object wordt gebruikt om threads te dwingen synchroon te lopen. De optionele blokkering parameter stelt u in staat om te bepalen of de thread wacht om het slot te verkrijgen.

Als blokkeren is ingesteld op 0, keert de thread onmiddellijk terug met een 0-waarde als het slot niet kan worden verkregen en met een 1 als het slot is verkregen. Als blokkeren is ingesteld op 1, blokkeert de draad en wacht tot de vergrendeling wordt vrijgegeven.

De release() methode van het nieuwe vergrendelingsobject wordt gebruikt om de vergrendeling op te heffen wanneer deze niet langer nodig is.

Voorbeeld

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

Wanneer de bovenstaande code wordt uitgevoerd, levert dit het volgende resultaat op −

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

Multithreaded prioriteitswachtrij

De Wachtrij module kunt u een nieuw wachtrij-object maken dat een specifiek aantal items kan bevatten. Er zijn de volgende methoden om de wachtrij te besturen −

get() − De get() verwijdert en retourneert een item uit de wachtrij.
put() − De put voegt item toe aan een wachtrij.
qsize() − De qsize() retourneert het aantal items dat momenteel in de wachtrij staat.
leeg() − De lege( ) retourneert True als de wachtrij leeg is; anders niet waar.
volledig() − de full() geeft True terug als de wachtrij vol is; anders niet waar.

Voorbeeld

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

Wanneer de bovenstaande code wordt uitgevoerd, levert dit het volgende resultaat op −

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 - E-mail verzenden met SMTP Python - XML-verwerking

Python