Fabrication industrielle
Internet des objets industriel | Matériaux industriels | Entretien et réparation d'équipement | Programmation industrielle |
home  MfgRobots >> Fabrication industrielle >  >> Industrial programming >> Python

Python - Programmation multithread

Page PrécédentePage Suivante

L'exécution de plusieurs threads est similaire à l'exécution simultanée de plusieurs programmes différents, mais avec les avantages suivants −

Un thread a un début, une séquence d'exécution et une conclusion. Il a un pointeur d'instruction qui garde une trace de l'endroit où il est en cours d'exécution dans son contexte.

Démarrer un nouveau fil

Pour générer un autre thread, vous devez appeler la méthode suivante disponible dans thread modules −

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

Cet appel de méthode permet de créer rapidement et efficacement de nouveaux threads sous Linux et Windows.

L'appel de méthode revient immédiatement et le thread enfant démarre et appelle la fonction avec la liste passée d'args . Lorsque la fonction revient, le thread se termine.

Ici, arguments est un tuple d'arguments ; utilisez un tuple vide pour appeler la fonction sans passer d'arguments. kwargs est un dictionnaire facultatif d'arguments de mots clés.

Exemple

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant −

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

Bien qu'il soit très efficace pour le threading de bas niveau, mais le thread est très limité par rapport au nouveau module de threading.

Le threading Module

Le nouveau module de threading inclus avec Python 2.4 fournit une prise en charge de haut niveau beaucoup plus puissante pour les threads que le module de thread discuté dans la section précédente.

Le threading module expose toutes les méthodes du thread module et fournit quelques méthodes supplémentaires −

En plus des méthodes, le module de threading a le Thread classe qui implémente le threading. Les méthodes fournies par le Thread classe sont les suivantes −

Créer un fil à l'aide de Threading Module

Pour implémenter un nouveau thread à l'aide du module de threading, vous devez faire ce qui suit −

Une fois que vous avez créé le nouveau Thread sous-classe, vous pouvez en créer une instance, puis démarrer un nouveau thread en appelant start() , qui à son tour appelle run() méthode.

Exemple

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant −

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

Synchroniser les fils

Le module de threading fourni avec Python comprend un mécanisme de verrouillage simple à mettre en œuvre qui vous permet de synchroniser les threads. Un nouveau verrou est créé en appelant le Lock() qui renvoie le nouveau verrou.

L'acquisition (blocage) La méthode du nouvel objet de verrouillage est utilisée pour forcer les threads à s'exécuter de manière synchrone. Le blocage facultatif Le paramètre vous permet de contrôler si le thread attend pour acquérir le verrou.

Si bloquant est mis à 0, le thread retourne immédiatement avec une valeur 0 si le verrou ne peut pas être acquis et avec un 1 si le verrou a été acquis. Si le blocage est défini sur 1, le thread se bloque et attend que le verrou soit libéré.

Le release() La méthode du nouvel objet de verrouillage est utilisée pour libérer le verrou lorsqu'il n'est plus nécessaire.

Exemple

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant −

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

File d'attente prioritaire multithread

La file d'attente Le module vous permet de créer un nouvel objet de file d'attente pouvant contenir un nombre spécifique d'éléments. Il existe les méthodes suivantes pour contrôler la file d'attente −

Exemple

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

Lorsque le code ci-dessus est exécuté, il produit le résultat suivant −

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

  1. Tutoriel SciPy en Python :qu'est-ce que c'est | Exemples de bibliothèque et de fonctions
  2. Python vs C++ :Quelle est la différence ?
  3. Fermetures Python
  4. Tutoriel PyUnit :Framework de test unitaire Python (avec exemple)
  5. Instruction Python if...else
  6. Python vérifie si le fichier existe | Comment vérifier si un répertoire existe en Python