Python - Multithread-Programmierung

Vorherige SeiteNächste Seite

Das Ausführen mehrerer Threads ähnelt dem gleichzeitigen Ausführen mehrerer verschiedener Programme, jedoch mit den folgenden Vorteilen −

Mehrere Threads innerhalb eines Prozesses teilen sich den gleichen Datenraum mit dem Haupt-Thread und können daher einfacher Informationen austauschen oder miteinander kommunizieren, als wenn sie separate Prozesse wären.
Threads werden manchmal als leichtgewichtige Prozesse bezeichnet und benötigen nicht viel Speicher-Overhead; sie sind billiger als Prozesse.

Ein Thread hat einen Anfang, eine Ausführungssequenz und einen Abschluss. Es hat einen Anweisungszeiger, der verfolgt, wo es in seinem Kontext gerade läuft.

Es kann präemptiv (unterbrochen) werden
Es kann vorübergehend angehalten werden (auch bekannt als schlafend), während andere Threads laufen - das nennt man yielding.

Starten eines neuen Threads

Um einen weiteren Thread zu erstellen, müssen Sie die folgende Methode aufrufen, die in thread verfügbar ist Modul −

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

Dieser Methodenaufruf ermöglicht eine schnelle und effiziente Möglichkeit, neue Threads sowohl unter Linux als auch unter Windows zu erstellen.

Der Methodenaufruf kehrt sofort zurück und der untergeordnete Thread startet und ruft die Funktion mit der übergebenen Liste von Argumenten auf . Wenn die Funktion zurückkehrt, wird der Thread beendet.

Hier, Argumente ist ein Tupel von Argumenten; Verwenden Sie ein leeres Tupel, um die Funktion aufzurufen, ohne Argumente zu übergeben. Kwargs ist ein optionales Wörterbuch mit Schlüsselwortargumenten.

Beispiel

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

Wenn der obige Code ausgeführt wird, erzeugt er das folgende Ergebnis −

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

Es ist zwar sehr effektiv für Low-Level-Threading, aber der Thread Modul ist im Vergleich zum neueren Threading-Modul sehr eingeschränkt.

Das Threading Modul

Das neuere Threading-Modul, das in Python 2.4 enthalten ist, bietet viel leistungsfähigere High-Level-Unterstützung für Threads als das Thread-Modul, das im vorherigen Abschnitt besprochen wurde.

Das Einfädeln -Modul legt alle Methoden des Threads offen Modul und bietet einige zusätzliche Methoden −

threading.activeCount() − Gibt die Anzahl der aktiven Thread-Objekte zurück.
threading.currentThread() − Gibt die Anzahl der Thread-Objekte in der Thread-Steuerung des Aufrufers zurück.
threading.enumerate() − Gibt eine Liste aller aktuell aktiven Thread-Objekte zurück.

Zusätzlich zu den Methoden hat das Threading-Modul den Thread Klasse, die Threading implementiert. Die vom Thread bereitgestellten Methoden Klasse sind wie folgt −

run() − Die Methode run() ist der Einstiegspunkt für einen Thread.
start() − Die Methode start() startet einen Thread, indem sie die Methode run aufruft.
beitreten([Zeit]) − Die Funktion join() wartet darauf, dass Threads beendet werden.
istAlive() − Die Methode isAlive() prüft, ob ein Thread noch läuft.
getName() − Die Methode getName() gibt den Namen eines Threads zurück.
setName() − Die Methode setName() setzt den Namen eines Threads.

Thread erstellen mit Threading Modul

Um einen neuen Thread mit dem Threading-Modul zu implementieren, müssen Sie Folgendes tun:−

Definieren Sie eine neue Unterklasse des Thread Klasse.
Überschreiben Sie __init__(self [,args]) Methode, um zusätzliche Argumente hinzuzufügen.
Überschreiben Sie dann die Methode run(self [,args]), um zu implementieren, was der Thread tun soll, wenn er gestartet wird.

Nachdem Sie den neuen Thread erstellt haben Unterklasse können Sie eine Instanz davon erstellen und dann einen neuen Thread starten, indem Sie start() aufrufen , die wiederum run() aufruft Methode.

Beispiel

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

Wenn der obige Code ausgeführt wird, erzeugt er das folgende Ergebnis −

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

Synchronisieren von Threads

Das mit Python bereitgestellte Threading-Modul enthält einen einfach zu implementierenden Sperrmechanismus, mit dem Sie Threads synchronisieren können. Eine neue Sperre wird durch den Aufruf von Lock() erstellt Methode, die die neue Sperre zurückgibt.

Die Erwerb(Blockierung) -Methode des neuen Sperrobjekts wird verwendet, um Threads zur synchronen Ausführung zu zwingen. Die optionale Blockierung Mit dem Parameter können Sie steuern, ob der Thread darauf wartet, die Sperre zu erwerben.

Wenn blockiert auf 0 gesetzt ist, kehrt der Thread sofort mit einem 0-Wert zurück, wenn die Sperre nicht erworben werden kann, und mit einer 1, wenn die Sperre erworben wurde. Wenn die Blockierung auf 1 gesetzt ist, blockiert der Thread und wartet, bis die Sperre aufgehoben wird.

Die Freigabe() Methode des neuen Sperrobjekts wird verwendet, um die Sperre freizugeben, wenn sie nicht mehr benötigt wird.

Beispiel

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

Wenn der obige Code ausgeführt wird, erzeugt er das folgende Ergebnis −

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 Priority Queue

Die Warteschlange Mit dem Modul können Sie ein neues Warteschlangenobjekt erstellen, das eine bestimmte Anzahl von Elementen enthalten kann. Es gibt folgende Methoden, um die Warteschlange zu steuern −

erhalten() − Das get() entfernt ein Element aus der Warteschlange und gibt es zurück.
put() − Der Put fügt Artikel zu einer Warteschlange hinzu.
qsize() − qsize() gibt die Anzahl der Elemente zurück, die sich derzeit in der Warteschlange befinden.
leer() − Empty( ) gibt True zurück, wenn die Warteschlange leer ist; andernfalls False.
voll() − full() gibt True zurück, wenn die Warteschlange voll ist; andernfalls False.

Beispiel

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

Wenn der obige Code ausgeführt wird, erzeugt er das folgende Ergebnis −

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 - Senden von E-Mails mit SMTP Python - XML-Verarbeitung

Python