Latest web development tutorials

Python Multithreaded

Mehrere Threads ausgeführt gleichzeitig ist ähnlich zu einer Anzahl von verschiedenen Programmen, multithreaded Betrieb hat die folgenden Vorteile:

  • Mit Threads können lange Programm in der Aufgabe in den Hintergrund zu besetzen, zu beschäftigen.
  • Die Benutzeroberfläche kann attraktiver sein, so zum Beispiel der Benutzer auf eine Schaltfläche klickt einige Event-Handling auszulösen, können Sie einen Fortschrittsbalken Pop der Fortschritt des Prozesses zu zeigen,
  • Laufgeschwindigkeit könnte beschleunigen
  • Auf realisiert einige Aufgaben, wie zum Beispiel eine Benutzereingabe wartet, Dokumenten Lese-, Schreib- und Netzwerkdaten zu senden und zu empfangen, ist der Faden nützlicher. In diesem Fall können wir einige wertvolle Ressourcen, wie Speichernutzung usw. frei.

Themen in den Umsetzungsprozess und der Prozess ist anders. Jedes verfügt über einen separaten Thread ausgeführt Eingang, Ausgang Folge und Verfahren für die Durchführung des Auftrages. Aber der Faden ist unabhängig auszuführen nicht in der Lage, es muss entsprechend existieren an die Anwendung, mehrere Ausführungs-Threads Bereitstellung durch die Anwendung gesteuert.

Jeder Thread hat seinen eigenen Satz von CPU-Register, genannt spiegelt der Kontext des Themas, der Thread-Kontext den letzten Lauf des Threads CPU-Register-Zustand.

Befehlszeiger und Stapelzeigerregister sind die beiden wichtigsten Thread-Kontext-Register, der Faden immer in Zusammenhang mit dem Prozess ausgeführt wird, werden diese Adressen verwendet, um den Prozeß zu kennzeichnen, die den Faden von dem Speicheradressenraum besitzt.

  • Gewinde können vorbelegt werden (unterbrochen).
  • In anderen Threads ausgeführt werden, kann der Faden in der Schwebe (auch bekannt als Schlaf) gehalten werden - dies ist der Faden der Zugeständnisse ist.

Starten Sie das Lernen Python-Threads

Python-Threads auf zwei Arten verwendet: mit einer Funktion oder Klasse, um die Thread-Objekt zu wickeln.

Funktional: Aufruf Thread Modul start_new_thread () Funktion einen neuen Thread zu erzeugen. Die Syntax lautet wie folgt: 

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

Parameter Beschreibung:

  • Funktion - Thread-Funktion.
  • args - die Faden Parameter an die Funktion übergeben, muss er ein Tupel-Typ sein.
  • kwargs - Optional.

Beispiel: 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import thread
import time

# 为线程定义一个函数
def print_time( threadName, delay):
   count = 0
   while count < 5:
      time.sleep(delay)
      count += 1
      print "%s: %s" % ( threadName, time.ctime(time.time()) )

# 创建两个线程
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

Die oben genannten Programmausgabe Ergebnisse sind wie folgt: 

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

Das Ende des Fadens ist beruhen im allgemeinen auf dem natürlichen Ende der Funktionsfaden, auch thread.exit Thread-Funktion () aufrufen können, er wirft Systemexit Ausnahme, erreichen den Zweck Faden zu verlassen.

Threading-Modul

Python bietet Unterstützung für Faden durch zwei Standardbibliotheken Einfädeln und Gewinden. Gewinde bietet eine Low-Level, das ursprüngliche Gewinde und eine einfache Sperre.

Andere Methoden Gewinde-Modul bietet:

  • threading.currentThread (): Gibt den aktuellen Thread-Variable.
  • threading.enumerate (): Gibt ein laufender Thread-Liste enthält. Bezieht sich laufenden Thread vor dem Ende begonnen, es nicht den Faden sind vor dem Start und nach der Beendigung.
  • threading.activeCount (): Gibt die Anzahl der Threads, die ausgeführt werden, und len (threading.enumerate ()) haben das gleiche Ergebnis.

Neben der Verwendung von Methoden, threading-Modul bietet auch eine Thread-Klasse den Faden, Thread-Klasse stellt die folgenden Methoden zu behandeln:

  • run (): die Methode der aktiven Threads anzuzeigen.
  • () Starten: Thread - Aktivität starten.

  • join ([Zeit]): Warten , bis der Thread abgebrochen.Dies blockiert den Aufruf Thread, bis der Thread join () Methode wird Suspension genannt - normale Ausfahrt oder eine nicht behandelte Ausnahme werfen - oder optionale Timeout auftritt.
  • IsAlive (): Gibt der Thread aktiv ist.
  • getName (): Gibt den Thread - Namen.
  • setName (): Stellen Sie den Thread - Namen.

Verwenden Sie Threading-Modul Threads zu erstellen

Verwenden Sie Threading-Modul einen Thread zu erstellen, direkt von threading.Thread geerbt, dann außer Kraft setzen __init__ Methode und führen Methoden: 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import threading
import time

exitFlag = 0

class myThread (threading.Thread):   #继承父类threading.Thread
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):                   #把要执行的代码写到run函数里面 线程在创建后会直接运行run函数 
        print "Starting " + self.name
        print_time(self.name, self.counter, 5)
        print "Exiting " + self.name

def print_time(threadName, delay, counter):
    while counter:
        if exitFlag:
            thread.exit()
        time.sleep(delay)
        print "%s: %s" % (threadName, time.ctime(time.time()))
        counter -= 1

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启线程
thread1.start()
thread2.start()

print "Exiting Main Thread"

Die oben genannten Programmausführung Ergebnisse sind wie folgt; 

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

Themen-Synchronisation

Wenn mehrere Threads einer gemeinsamen Datenänderung kann unvorhersagbare Ergebnisse auftreten, um die Richtigkeit der Daten zu gewährleisten, müssen wir mehrere Threads zu synchronisieren.

Thread-Objekt mit dem Schloss und RLOCK können eine einfache Thread-Synchronisation zu erreichen, die beiden Objekte haben Methoden erwerben und Freisetzung Methoden, für diejenigen, die jeweils so dass nur ein Thread Betriebsdaten benötigen, kann sie in Betrieb acquire platziert werden und lassen Sie Methoden der Zimmer. Wie folgt:

Multithreading Vorteil ist, dass es mehrere Aufgaben gleichzeitig ausgeführt werden können (zumindest fühlt sich an wie diese). Aber wenn Threads benötigen, um Daten zu teilen, kann es keine Daten-Synchronisierungsprobleme sein.

Betrachten wir einen Fall: eine Liste aller Elemente Null sind, der Thread "set" von hinten nach vorne alle Elemente in einem, und der Faden "Drucken" von vorne in Ladung Rückseite der Liste und drucken zu lesen.

Dann kann der Faden "gesetzt" werden, begann sich zu ändern, wenn der Thread "Drucken" eine Liste zu drucken, wäre es eine 0 Hälfte der Ausgang der Hälfte sein, die die Daten nicht synchronisiert ist. Um diese Situation zu vermeiden, führen wir das Konzept des Schlosses.

Sperre hat zwei Zustände - verriegelt und entriegelt. Jedes Mal, wenn ein Thread wie "set" die gemeinsamen Daten zugreifen zu können, müssen Sie zuerst die Sperre erhalten, wenn Sie bereits ein anderes Gewinde haben, wie zum Beispiel "Drucken" zu erhalten eingesperrt, dann lassen Sie den Faden "set" Pause, die synchrone Sperrung ist, bis der Faden warten " drucken "Zugriff abgeschlossen ist, nach der Freigabe des Schlosses, lassen Sie den Faden" Set ", um fortzufahren.

Nach diesem Prozess, wenn Sie eine Liste aller Ausgaben entweder 0 oder 1 volle Leistung zu drucken, wird nicht mehr die Hälfte Verlegenheit 0 1 halb.

Beispiel: 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

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
       # 获得锁，成功获得锁定后返回True
       # 可选的timeout参数不填时将一直阻塞直到获得锁定
       # 否则超时后将返回False
        threadLock.acquire()
        print_time(self.name, self.counter, 3)
        # 释放锁
        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 = []

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()

# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)

# 等待所有线程完成
for t in threads:
    t.join()
print "Exiting Main Thread"

Thread-Priorität-Warteschlange (Queue)

Pythons Queue-Modul ermöglicht die Synchronisierung, Thread-sichere Warteschlange Klassen, einschließlich FIFO (first in first out) Warteschlange Queue, LIFO (last in, first out) Warteschlange LifoQueue und Prioritätswarteschlange Priorityqueue. Diese Warteschlangen sind implementiert Verriegelungs Primitiven direkt in mehrere Threads verwendet werden können. Sie können die Warteschlange verwenden Synchronisation zwischen Threads zu erreichen.

Queue-Modul häufigsten verwendeten Methoden:

  • Queue.qsize () gibt die Größe der Warteschlange
  • Queue.empty (), wenn die Warteschlange leer ist, gibt True, False und umgekehrt
  • Queue.full () Wenn die Warteschlange voll ist, zurückgeben True, False und umgekehrt
  • Entsprechend der Größe und maxsize Queue.full
  • Queue.get ([Block [, timeout]]) Ruft die Warteschlange, Timeout Wartezeit
  • Queue.get_nowait () eher Queue.get (False)
  • Queue.put (Artikel) Schreibwarteschlange, Timeout Wartezeit
  • Queue.put_nowait (Artikel) ganz Queue.put (item, False)
  • Queue.task_done () nach Beendigung eines Arbeits, Queue.task_done () Funktion sendet ein Signal an die Aufgabenwarteschlange abgeschlossen wurde
  • Queue.join () bedeutet, wirklich, bis die Warteschlange leer ist, dann andere Operationen ausführen

Beispiel: 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

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

# 创建新线程
for tName in threadList:
    thread = myThread(threadID, tName, workQueue)
    thread.start()
    threads.append(thread)
    threadID += 1

# 填充队列
queueLock.acquire()
for word in nameList:
    workQueue.put(word)
queueLock.release()

# 等待队列清空
while not workQueue.empty():
    pass

# 通知线程是时候退出
exitFlag = 1

# 等待所有线程完成
for t in threads:
    t.join()
print "Exiting Main Thread"

Die Ergebnisse des obigen Programms: 

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