Ein einfaches Verständnis von Python-Multithreading und Thread-Sperren (Code)

Dieser Artikel vermittelt Ihnen ein einfaches Verständnis (Code) von Python-Multithreading und Thread-Sperren. Ich hoffe, dass er für Freunde hilfreich ist.

Multithreading-Threading-Modul erstellt Threads, erstellt eine eigene Thread-Klasse, Thread-Kommunikation, Thread-Synchronisierung, gegenseitige Ausschlussmethode, Thread-Sperre@muss man wissen! ! !

Multi-Threading

Was ist ein Thread?

Threads sind auch eine Multitasking-Programmiermethode, die Computer-Multicore-Ressourcen nutzen kann, um die gleichzeitige Ausführung von Programmen abzuschließen.

Threads werden auch als Lightweight-Prozesse bezeichnet

Eigenschaften von Threads

Threads sind die kleinste Einheit der Computer-Mehrkernzuordnung

Ein Prozess kann mehrere Threads enthalten

Ein Thread ist auch ein laufender Prozess, der Computerressourcen verbraucht.

Das Erstellen und Löschen von Threads verbraucht weitaus weniger Ressourcen als der Prozess.

Die Ausführung mehrerer Threads stört einander nicht

Threads haben auch ihre eigenen eindeutigen Attribute, wie z. B. die Befehlssatz-ID

Threading-Modul erstellt Threads

t =threading.Thread( )

Name: Thread-Name, Standardwert, wenn leer, Tread-1, Tread-2, Tread-3

Ziel: Thread-Funktion

args : Elementgruppe, Parameter entsprechend der Position an die Thread-Funktion übergeben

kwargs: Wörterbuch, Parameter entsprechend dem Schlüsselwert an die Kreisfunktion übergeben

Funktion: Thread-Objekt erstellen

Parameter

t.start(): Thread starten und Thread-Funktion automatisch ausführen

t.join([timeout]): Prozess wiederverwenden

t.is_alive( ): Thread-Status anzeigen

t.name(): Thread-Namen anzeigen

t.setName(): Thread-Namen festlegen

t.daemon-Attribut: Von Standardmäßig wird der Hauptthread beendet und hat keinen Einfluss auf die weitere Ausführung des Zweigthreads. Wenn festgelegt, wird der Zweigthread zusammen mit dem Hauptthread beendet

t.daemon = True

t. setDaemon(Ture)

Einstellungsmethode

#!/usr/bin/env python3
from threading import Thread
from time import sleep
import os
# 创建线程函数
def music():
    sleep(2)
    print("分支线程")

t = Thread(target = music)
# t.start()   # ******************************
print("主线程结束---------")

'''没有设置的打印结果
主线程结束---------
分支线程
'''

'''设置为True打印结果
主线程结束---------
'''

threading .currentThread: Aktuelles Thread-Objekt abrufen

@Der Code hier zeigt an, dass die Unterthreads Variablen im selben Prozess gemeinsam nutzen

#!/usr/bin/env python3
from threading import Thread
from time import sleep
import os

# Thread-Funktion erstellen
def music( ):
global a
print("a=",a)
a = 10000
für i in range(5):
sleep(1)
print("1212 ")

a = 1
t = Thread(target = music)
t.start()
t.join()
print("a des Hauptthreads = ",a) Erstellen Sie Ihre eigene Thread-Klasse

Inspektionspunkte: Verwendung der Klasse, Aufruf der übergeordneten Methode __init__ der Klasse, Funktion *Parameterübergabe und **Parameterübergabe

from threading import Thread
import time

class MyThread(Thread):
    name1 = 'MyThread-1'
    def __init__(self,target,args=(), kwargs={}, name = 'MyThread-1'):
        super().__init__()
        self.name = name
        self.target = target
        self.args = args
        self.kwargs = kwargs
    def run(self):
        self.target(*self.args,**self.kwargs)

def player(song,sec):
    for i in range(2):
        print("播放 %s：%s"%(song,time.ctime()))
        time.sleep(sec)

t =MyThread(target = player, args = ('亮亮',2))

t.start()
t.join()

Thread-Kommunikation

Kommunikationsmethode: Da mehrere Threads den Prozess gemeinsam nutzen Speicherplatz, sodass die Kommunikation zwischen Threads mithilfe globaler Variablen abgeschlossen werden kann

Hinweis: Bei Verwendung Globale Variablen zwischen Threads, häufig ist ein Mechanismus zum gegenseitigen Ausschluss der Synchronisation erforderlich, um die Sicherheit der Kommunikation sicherzustellen

Methode zum gegenseitigen Ausschluss der Thread-Synchronisation

Ereignis

e = threading.Event() : Ereignisobjekt erstellen

e.wait([timeout]): Status festlegen Wenn dieser festgelegt wurde, blockiert diese Funktion den Timeout-Zeitraum

e.set: e in den eingestellten Zustand ändern

e.clear: Den eingestellten Zustand löschen

import threading
from time import sleep

def fun1():
    print("bar拜山头")
    global s
    s = "天王盖地虎"

def fun2():
    sleep(4)
    global s
    print("我把限制解除了")
    e.set()     # 解除限制，释放资源

def fun3():
    e.wait() # 检测限制
    print("说出口令")
    global s
    if s == "天王盖地虎":
        print("宝塔镇河妖，自己人")
    else:
        print("打死他")
    s = "哈哈哈哈哈哈"

# 创建同步互斥对象
e = threading.Event()
# 创建新线程
f1 = threading.Thread(target = fun1)
f3 = threading.Thread(target = fun3)
f2 = threading.Thread(target = fun2)
# 开启线程
f1.start()
f3.start()
f2.start()
#准备回收
f1.join()
f3.join()
f2.join()

Thread lock

lock = threading.Lock( ): Erstellen Sie ein Sperrobjekt

lock.acquire(): Sperren

lock.release(): Entsperren

Sie können auch mit verwenden, um

1 with lock:
2     ...
3     ...

Das obige ist der detaillierte Inhalt vonEin einfaches Verständnis von Python-Multithreading und Thread-Sperren (Code). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!