Eine Einführung in Multithreading in Python

Multithreading kann einfach als die gleichzeitige Ausführung mehrerer Aufgaben verstanden werden. In diesem Artikel werden detaillierte Beispiele für Python-Multithreading-Threading-Anfänger-Tutorials vorgestellt. Interessierte Freunde können gemeinsam lernen

1.1 Was ist Multithreading

Unter Multithreading kann einfach das gleichzeitige Ausführen mehrerer Aufgaben verstanden werden.

Sowohl Multiprozess als auch Multithreading können mehrere Aufgaben ausführen, und Threads sind Teil des Prozesses. Das Merkmal von Threads besteht darin, dass sie Speicher und Variablen zwischen Threads gemeinsam nutzen können und weniger Ressourcen verbrauchen (in der Unix-Umgebung ist der Unterschied im Ressourcenplanungsverbrauch zwischen Multiprozess und Multithread jedoch nicht offensichtlich, und die Unix-Planung ist schneller ). Der Nachteil ist, dass die Synchronisierung und Beschleunigung zwischen Threads problematischer ist.

1.2 Thread-Thread hinzufügen

Modul importieren

import threading

Erhaltene Nummer der aktivierten Threads

threading.active_count()

Alle Threadinformationen anzeigen

threading.enumerate()

Die derzeit laufenden Threads anzeigen

threading.current_thread()

Fügen Sie einen Thread hinzu, threading.Thread()erhält den Parameter target, um die von diesem Thread auszuführende Aufgabe darzustellen. Sie müssen ihn selbst definieren

def thread_job():
  print('This is a thread of %s' % threading.current_thread())
def main():
  thread = threading.Thread(target=thread_job,)  # 定义线程 
  thread.start() # 让线程开始工作
  if __name__ == '__main__':
  main()

1.3 Join-Funktion

Da die Threads gleichzeitig ausgeführt werden, ermöglicht die Verwendung der Join-Funktion den Thread um den nächsten Schritt abzuschließen, bevor mit dem nächsten Vorgang fortgefahren wird, d. h. dem Blockieren. Der aufrufende Thread wartet, bis alle Aufgaben in der Warteschlange verarbeitet wurden.

import threading
import time
def thread_job():
  print('T1 start\n')
  for i in range(10):
    time.sleep(0.1)
  print('T1 finish\n')
def T2_job():
  print('T2 start\n')
  print('T2 finish\n')
def main():
  added_thread=threading.Thread(target=thread_job,name='T1')
  thread2=threading.Thread(target=T2_job,name='T2')
  added_thread.start()
  #added_thread.join()
  thread2.start()
  #thread2.join()
  print('all done\n')
if __name__=='__main__':
   main()

Das Beispiel ist oben dargestellt. Wenn die Join-Funktion nicht verwendet wird, ist das Ergebnis wie folgt:

Wenn die Join-Funktion ausgeführt wird, wird T2 erst ausgeführt, nachdem T1 die Ausführung beendet hat, und dann wird print ausgeführt („alles erledigt“)

1.4 Warteschlange zum Speichern von Prozessergebnissen

Warteschlange ist eine Thread-sichere Warteschlangen-Implementierung (FIFO) in der Python-Standardbibliothek, die ein First-in- First-Out-Methode, geeignet für Multithread-Programmierung. Datenstrukturen, nämlich Warteschlangen, werden zum Übertragen von Informationen zwischen Produzenten- und Konsumenten-Threads verwendet

(1) Grundlegende FIFO-Warteschlange

 class queue.Queue(maxsize=0)

maxsize ist eine Ganzzahl, die die Obergrenze der Anzahl der Daten angibt, die in der Warteschlange gespeichert werden können. Wenn die Obergrenze erreicht ist, führt das Einfügen zu einer Blockierung, bis die Daten in der Warteschlange verbraucht sind kleiner oder gleich 0 ist, gibt es keine Begrenzung für die Warteschlangengröße

(2) LIFO-Warteschlange Last In First Out

class queue.LifoQueue(maxsize=0)

( 3) Prioritätswarteschlange

class queue.PriorityQueue(maxsize=0)

Der Code im Video ist nicht sehr klar

import threading
import time
from queue import Queue
def job(l,q):
  for i in range(len(l)):
    l[i]=l[i]**2
  q.put(l)
def multithreading():
  q=Queue()
  threads=[]
  data=[[1,2,3],[3,4,5],[4,5,6],[5,6,7]]
  for i in range(4):
    t=threading.Thread(target=job,args=(data[i],q))
    t.start()
    threads.append(t)
  for thread in threads:
    thread.join()
  results=[]
  for _ in range(4):
    results.append(q.get())
  print(results)
if __name__=='__main__':
   multithreading()

Der Das laufende Ergebnis ist wie folgt

1.5 GIL ist möglicherweise nicht effizient

Global Interpreter Lock, Python ist Durch die von der virtuellen Python-Maschine ausgeführte Steuerung (auch als Interpreter-Hauptschleife bezeichnet) steuert GIL den Zugriff auf die virtuelle Python-Maschine und stellt sicher, dass immer nur ein Thread im Interpreter ausgeführt wird. In einer Multithread-Umgebung wird die virtuelle Python-Maschine wie folgt ausgeführt:

1. GIL festlegen

2 :

a. Geben Sie die Anzahl der Bytecode-Anweisungen an, oder

b Der Thread gibt die Kontrolle aktiv auf (time.sleep(0) kann aufgerufen werden)

4. Legen Sie den Thread für den Ruhezustand fest

5. GIL entsperren

6. Wiederholen Sie 1-5

Beim Aufrufen von externem Code (z. B. C/C++-Erweiterungsfunktionen) wird die GIL wird bis zum Ende dieser Funktion gesperrt (da in diesem Zeitraum kein Python-Bytecode ausgeführt wird, wird kein Threadwechsel durchgeführt).

Das Folgende ist das Codebeispiel im Video. Es erweitert eine Zahl um das Vierfache, teilt sie in die normale Methode auf und weist sie 4 Threads zu.

Das laufende Ergebnis ist:

import threading
from queue import Queue
import copy
import time
def job(l, q):
  res = sum(l)
  q.put(res)
def multithreading(l):
  q = Queue()
  threads = []
  for i in range(4):
    t = threading.Thread(target=job, args=(copy.copy(l), q), name='T%i' % i)
    t.start()
    threads.append(t)
  [t.join() for t in threads]
  total = 0
  for _ in range(4):
    total += q.get()
  print(total)
def normal(l):
  total = sum(l)
  print(total)
if __name__ == '__main__':
  l = list(range(1000000))
  s_t = time.time()
  normal(l*4)
  print('normal: ',time.time()-s_t)
  s_t = time.time()
  multithreading(l)
  print('multithreading: ', time.time()-s_t)

1.6 线程锁 Lock

如果线程1得到了结果，想要让线程2继续使用1的结果进行处理，则需要对1lock，等到1执行完，再开始执行线程2。一般来说对share memory即对共享内存进行加工处理时会用到lock。

import threading
def job1():
  global A, lock #全局变量
  lock.acquire() #开始lock
  for i in range(10):
    A += 1
    print('job1', A)
  lock.release() #释放
def job2(): 
  global A, lock
  lock.acquire()
  for i in range(10):
    A += 10
    print('job2', A)
  lock.release()
if __name__ == '__main__':
  lock = threading.Lock()
  A = 0
  t1 = threading.Thread(target=job1)
  t2 = threading.Thread(target=job2)
  t1.start()
  t2.start()
  t1.join()
  t2.join()

运行结果如下所示：

总结

Das obige ist der detaillierte Inhalt vonEine Einführung in Multithreading in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!