Il miglior tutorial python3 Multithreading Nel 2024, in questo tutorial puoi imparare Iniziare ad imparare le discussioni Python,modulo threading,Utilizzare modulo threading per creare un filo,sincronizzazione dei thread,coda di priorità del thread (coda),
Più thread eseguiti contemporaneamente è simile a una serie di programmi diversi, operazione multithread presenta i seguenti vantaggi:
Thread nel processo di attuazione e il processo è diverso. Ciascuno ha un thread separato esecuzione ingresso, sequenza di uscita e le procedure per l'attuazione dell'ordine. Ma il filo non è in grado di eseguire autonomamente, deve esistere seconda dell'applicazione, fornendo più thread di esecuzione controllati dall'applicazione.
Ogni thread ha il proprio set di registri della CPU, chiamato il contesto del thread, il contesto filo riflette l'ultima esecuzione dello stato filo registro della CPU.
puntatore all'istruzione e puntatore stack di registri sono i due più importanti registri di contesto filo, il filo sempre viene eseguito nel contesto del processo, questi indirizzi sono usati per marcare il processo che possiede il filo di spazio di indirizzi di memoria.
Discussione possono essere suddivisi in:
Python3 filo conduttore di due moduli:
Modulo thread è stato abbandonato. Gli utenti possono utilizzare al posto del modulo threading. Così, in python3 non può più utilizzare il modulo "filo". Per la compatibilità, filo python3 rinominerà "_thread".
le discussioni di pitone utilizzata in due modi: con una funzione o di classe per avvolgere l'oggetto thread.
Funzionale: Call funzione _thread modulo start_new_thread () per generare un nuovo thread. La sintassi è la seguente:
_thread.start_new_thread ( function, args[, kwargs] )
Descrizione Parametro:
esempio:
#!/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
I risultati di output sopra programma sono i seguenti:
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
Dopo aver eseguito il processo di cui sopra può premere Ctrl-C per uscire.
Python3 fornisce il supporto per la filettatura attraverso due _thread libreria standard e filettatura.
_thread fornisce un basso livello, il thread originale e di una serratura semplice, viene confrontato con il modulo funzionale filettatura è ancora relativamente limitata.
Altri metodi, oltre a modulo threading contiene moduli _thread tutti i metodi, ma anche per fornire:
Oltre all'uso di metodi, modulo threading fornisce anche una classe Thread per gestire il filo, classe Thread fornisce i seguenti metodi:
Ci possono essere creati direttamente ereditato da threading.Thread una nuova sotto-classe, dopo il metodo di inizio e di istanziare (chiamata) per avviare un nuovo thread, che si chiama il metodo run del 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 ("退出主线程")
I risultati di esecuzione sopra programma sono i seguenti;
开始线程: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 退出主线程
Se più thread di una modifica di dati comune, potrebbero verificarsi risultati imprevedibili, al fine di assicurare l'accuratezza dei dati, abbiamo bisogno di sincronizzare più thread.
oggetto filo con il blocco e RLOCK può realizzare una semplice sincronizzazione dei thread, i due oggetti hanno metodi di acquisire e metodi di rilascio, per chi ha bisogno ciascuno dei quali permette solo uno dei dati di funzionamento del filo, può essere messo in funzione acquisire e rilasciare i metodi della stanza. Come segue:
Multithreading vantaggio è che può eseguire contemporaneamente più attività (almeno si sente come questo). Ma quando le discussioni hanno bisogno di condividere i dati, non ci possono essere problemi di sincronizzazione dei dati.
Si consideri un caso: un elenco di tutti gli elementi sono pari a zero, il thread "set" da dietro in avanti tutti gli elementi in un unico, e la "stampa" filo da davanti a dietro responsabile della lettura della lista e stampa.
Quindi, il filo potrebbe essere "set" inizia a cambiare quando la "stampa" filo per stampare una lista, sarebbe metà della produzione di mezzo 0, che è il dato non è sincronizzato. Per evitare questa situazione, si introduce il concetto della serratura.
Blocco ha due stati - bloccato e sbloccato. Ogni volta che un filo, come "set" per accedere ai dati condivisi, è necessario prima acquisire il blocco, se si dispone già di un altro thread, come ad esempio "stampa" per ottenere bloccato, poi lasciare il filo "set" di pausa, che è il blocco sincrono, attendere che il filo " stampare "l'accesso è completata, dopo il rilascio della serratura, lasciare che il filo" set "per continuare.
Dopo questo processo, quando si stampa un elenco di tutti gli output 0 o 1 uscita completa, non appare più la metà imbarazzo 0 1 mezza.
esempio:
#!/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 ("退出主线程")
Il programma precedente, l'uscita è:
开启线程: 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 退出主线程
Modulo Coda di Python fornisce la sincronizzazione, le classi di coda thread-safe, tra cui FIFO (First In First Out) della coda della coda, LIFO (last in, first out) coda LifoQueue, e coda di priorità CodaConPriorita.
Queste code vengono implementate bloccaggio primitive possono essere utilizzati direttamente in un multithread, è possibile utilizzare la coda per ottenere la sincronizzazione tra i thread.
modulo coda metodi comunemente usati:
esempio:
#!/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 ("退出主线程")
I risultati del programma di cui sopra:
开启线程: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 退出主线程