In einer Multithread-Umgebung hat jeder Thread seine eigenen Daten. Es ist besser, wenn ein Thread seine eigenen lokalen Variablen verwendet, als globale Variablen, da lokale Variablen nur vom Thread selbst gesehen werden können und keine Auswirkungen auf andere Threads haben und die Änderung globaler Variablen gesperrt werden muss .
Es gibt aber auch Probleme mit lokalen Variablen, dh es ist schwierig zu übergeben, wenn die Funktion aufgerufen wird:
def process_student(name):
std = Student(name)
# std是局部变量，但是每个函数都要用它，因此必须传进去：
do_task_1(std)
do_task_2(std)
def do_task_1(std):
do_subtask_1(std)
do_subtask_2(std)
def do_task_2(std):
do_subtask_2(std)
do_subtask_2(std)
Wie wäre es, die Parameter jeder Funktion Schicht für Schicht zu übergeben? Globale Variablen verwenden? Auch nicht, da jeder Thread unterschiedliche Student-Objekte verarbeitet und nicht freigegeben werden kann.
Wie wäre es, wenn Sie ein globales Diktat zum Speichern aller Student-Objekte verwenden und dann den Thread selbst als Schlüssel verwenden, um das Student-Objekt zu erhalten, das dem Thread entspricht?
global_dict = {
}
def std_thread(name):
std = Student(name)
# 把std放到全局变量global_dict中：
global_dict[threading.current_thread()] = std
do_task_1()
do_task_2()
def do_task_1():
# 不传入std，而是根据当前线程查找：
std = global_dict[threading.current_thread()]
...
def do_task_2():
# 任何函数都可以查找出当前线程的std变量：
std = global_dict[threading.current_thread()]
...
Diese Methode ist theoretisch machbar und ihr größter Vorteil besteht darin, dass das Problem der Übergabe von Standardobjekten in jeder Funktionsschicht beseitigt wird. Der Code zum Erhalten von Standardobjekten für jede Funktion ist jedoch etwas hässlich.
Gibt es einen einfacheren Weg?
ThreadLocal ist entstanden. Sie müssen nicht nach Diktaten suchen, ThreadLocal erledigt dies automatisch für Sie:
import threading
# 创建全局ThreadLocal对象：
local_school = threading.local()
def process_student():
# 获取当前线程关联的student:
std = local_school.student
print('Hello, %s (in %s)' % (std, threading.current_thread().name))
def process_thread(name):
# 绑定ThreadLocal的student：
local_school.student = name
process_student()
t1 = threading.Thread(target=process_thread, args=('Alice',), name='Thread-A')
t2 = threading.Thread(target= process_thread, args=('Bob',), name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()
Ergebnisse der:
Hello, Alice (in Thread-A)
Hello, Bob (in Thread-B)
Die globale Variable local_school ist ein ThreadLocal-Objekt, und jeder Thread kann Schülerattribute lesen und schreiben, wirkt sich jedoch nicht gegenseitig aus. Sie können local_school als globale Variable behandeln, aber jedes Attribut entspricht local_school. Studenten sind alle lokalen Variablen von Threads, die nach Belieben gelesen und geschrieben werden können, ohne sich gegenseitig zu stören, und es besteht keine Notwendigkeit, das Sperrproblem zu verwalten, das von ThreadLocal intern behandelt wird.
Es versteht sich, dass die globale Variable local_school ein Diktat ist, nicht nur local_school.student kann verwendet werden, sondern auch andere Variablen wie local_school.teacher können gebunden werden.
Der häufigste Ort für ThreadLocal ist das Binden einer Datenbankverbindung, einer HTTP-Anforderung, Benutzeridentitätsinformationen usw. für jeden Thread, damit alle von einem Thread aufgerufenen Verarbeitungsfunktionen sehr bequem auf diese Ressourcen zugreifen können.
Zusammenfassung
Eine ThreadLocal-Variable, aber jeder Thread kann nur eine unabhängige Kopie seines eigenen Threads lesen und schreiben, ohne sich gegenseitig zu stören . ThreadLocal löst das Problem der Übergabe von Parametern zwischen verschiedenen Funktionen in einem Thread.