Le meilleur didacticiel python3 Multithreading en 2024, dans ce didacticiel, vous pouvez apprendre Commencer à apprendre fils Python,Module threading,Utilisez le module threading pour créer un fil,Synchronisation Thread,file d'attente prioritaire Thread (file d'attente),
Plusieurs threads exécutés simultanément est similaire à un certain nombre de programmes différents, le fonctionnement multithread présente les avantages suivants:
Discussions dans le processus de mise en œuvre et le processus est différent. Chacun a un thread séparé en cours d'exécution d'entrée, la séquence de sortie et les procédures pour la mise en œuvre de l'ordre. Mais le fil ne sont pas en mesure d'effectuer de façon indépendante, il doit exister en fonction de l'application, fournissant de multiples fils d'exécution contrôlées par l'application.
Chaque thread a son propre ensemble de registres CPU, appelé le contexte du fil, le contexte de fil reflète la dernière exécution de l'état du fil de registre de CPU.
pointeur d'instruction et pointeur de la pile des registres sont les deux plus importants registres de contexte de fil, le fil se fait toujours exécuter dans le contexte du processus, ces adresses sont utilisées pour marquer le processus qui possède le fil de l'espace d'adressage de la mémoire.
Discussion peut être divisé en:
Python3 dénominateur commun de deux modules:
module de fil a été abandonné. Les utilisateurs peuvent utiliser le module de filetage à la place. Donc, en python3 ne peut plus utiliser le module "thread". Pour la compatibilité, le fil python3 va renommer "_thread".
fils de Python utilisés de deux manières: avec une fonction ou une classe pour envelopper l'objet thread.
Fonctionnel: Appel de la fonction _thread Module start_new_thread () pour générer un nouveau thread. La syntaxe est la suivante:
_thread.start_new_thread ( function, args[, kwargs] )
Description Paramètre:
exemple:
#!/usr/bin/python3 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: 无法启动线程") while 1: pass
Les résultats de sortie du programme ci-dessus sont les suivantes:
Thread-1: Wed Apr 6 11:36:31 2016 Thread-1: Wed Apr 6 11:36:33 2016 Thread-2: Wed Apr 6 11:36:33 2016 Thread-1: Wed Apr 6 11:36:35 2016 Thread-1: Wed Apr 6 11:36:37 2016 Thread-2: Wed Apr 6 11:36:37 2016 Thread-1: Wed Apr 6 11:36:39 2016 Thread-2: Wed Apr 6 11:36:41 2016 Thread-2: Wed Apr 6 11:36:45 2016 Thread-2: Wed Apr 6 11:36:49 2016
Après l'exécution de la procédure ci-dessus peut appuyer sur ctrl-c pour quitter.
Python3 fournir un soutien pour enfiler à travers deux _thread de bibliothèque standard et le filetage.
_thread fournit un niveau faible, le fil original et une serrure simple, il est comparé au module de fonction de filetage est encore relativement limitée.
D'autres méthodes, en plus de module de filetage contient le module _thread toutes les méthodes, mais aussi à fournir:
En plus de l'utilisation de méthodes, module de filetage fournit également une classe Thread pour manipuler le fil, classe Thread fournit les méthodes suivantes:
Nous pouvons être créés directement héritée de threading.Thread une nouvelle sous-classe, après la méthode start et instancier (appel) pour démarrer un nouveau thread, qu'il appelle la méthode d'exécution du thread ():
#!/usr/bin/python3 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 ("开始线程:" + self.name) print_time(self.name, self.counter, 5) print ("退出线程:" + self.name) def print_time(threadName, delay, counter): while counter: if exitFlag: threadName.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() thread1.join() thread2.join() print ("退出主线程")
Les résultats de l'exécution du programme ci-dessus sont les suivantes;
开始线程:Thread-1 开始线程:Thread-2 Thread-1: Wed Apr 6 11:46:46 2016 Thread-1: Wed Apr 6 11:46:47 2016 Thread-2: Wed Apr 6 11:46:47 2016 Thread-1: Wed Apr 6 11:46:48 2016 Thread-1: Wed Apr 6 11:46:49 2016 Thread-2: Wed Apr 6 11:46:49 2016 Thread-1: Wed Apr 6 11:46:50 2016 退出线程:Thread-1 Thread-2: Wed Apr 6 11:46:51 2016 Thread-2: Wed Apr 6 11:46:53 2016 Thread-2: Wed Apr 6 11:46:55 2016 退出线程:Thread-2 退出主线程
Si plusieurs threads d'une modification de données commune, des résultats imprévisibles peuvent se produire, afin d'assurer l'exactitude des données, nous avons besoin de synchroniser plusieurs threads.
objet Thread utilisant le verrou et RLOCK peut réaliser une synchronisation de fil simple, les deux objets ont des méthodes d'acquérir et de méthodes de libération, pour ceux qui ont besoin chacun permettant seulement une donnée de fonctionnement de fil, il peut être mis en service à acquérir et à libérer les méthodes de la la chambre. Comme suit:
Multithreading avantage est qu'il peut exécuter simultanément des tâches multiples (au moins se sent comme ça). Mais lorsque les discussions ont besoin de partager des données, il peut y avoir aucun problème de synchronisation des données.
Prenons un cas: une liste de tous les éléments sont nuls, le fil "set" de l'arrière vers l'avant tous les éléments en un seul, et le fil "print" d'avant en arrière en charge de la lecture de la liste et l'impression.
Ensuite, le fil peut être "réglé" a commencé à changer lorsque le fil "print" pour imprimer une liste, il serait la moitié de la sortie d'un demi-0, ce qui est les données ne sont pas synchronisées. Pour éviter cette situation, nous introduisons le concept de la serrure.
Verrouiller a deux états - verrouillé et déverrouillé. Chaque fois un fil tel que le "set" pour accéder aux données partagées, vous devez d'abord obtenir le verrou, si vous avez déjà un autre thread, comme "print" pour obtenir enfermé, puis laisser le fil "set" pause, ce qui est le blocage synchrone; attendre jusqu'à ce que le fil " imprimer "l'accès est terminé, après la sortie de la serrure, laissez le fil" set "pour continuer.
Après ce processus, lorsque vous imprimez une liste de toutes les sorties 0 ou 1 sortie complète, ne semble plus la moitié embarras 0 1 demi.
exemple:
#!/usr/bin/python3 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 ("开启线程: " + self.name) # 获取锁,用于线程同步 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 ("退出主线程")
Le programme ci-dessus, le résultat est:
开启线程: Thread-1 开启线程: Thread-2 Thread-1: Wed Apr 6 11:52:57 2016 Thread-1: Wed Apr 6 11:52:58 2016 Thread-1: Wed Apr 6 11:52:59 2016 Thread-2: Wed Apr 6 11:53:01 2016 Thread-2: Wed Apr 6 11:53:03 2016 Thread-2: Wed Apr 6 11:53:05 2016 退出主线程
Le module Queue de Python fournit la synchronisation, les classes de file d'attente thread-safe, y compris FIFO (first in first out) file d'attente de file d'attente, LIFO (dernier entré, premier sorti) file d'attente LifoQueue et file d'attente prioritaire PriorityQueue.
Ces files d'attente sont mises en œuvre primitives de verrouillage peuvent être utilisés directement dans un multithread, vous pouvez utiliser la file d'attente pour obtenir une synchronisation entre les threads.
module Queue méthodes couramment utilisées:
exemple:
#!/usr/bin/python3 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 ("开启线程:" + self.name) process_data(self.name, self.q) print ("退出线程:" + 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 ("退出主线程")
Les résultats du programme ci-dessus:
开启线程:Thread-1 开启线程:Thread-2 开启线程:Thread-3 Thread-3 processing One Thread-1 processing Two Thread-2 processing Three Thread-3 processing Four Thread-1 processing Five 退出线程:Thread-3 退出线程:Thread-2 退出线程:Thread-1 退出主线程