Warum sind Änderungen, die ein Thread an gemeinsam genutzten Variablen vornimmt, für andere Threads in Python unsichtbar?

Frageninhalt

Ich habe versucht, dieselbe Variable in mehreren Threads zu verwenden, aber der Wert der Variablen wurde in allen Threads nicht konsistent aktualisiert. Wenn beispielsweise Thread 1 eine Variable auf 1 aktualisiert, erkennt Thread 2 diese Änderung nicht und sieht stattdessen den alten Wert.

Hier ist ein einfaches Codebeispiel, das das Problem veranschaulicht. Wenn der Benutzer die Taste „a“ drückt, sollte die Variable „query“ aktualisiert und wie folgt angezeigt werden:

1. Abfrage 1: a
2. Abfrage: a

Die tatsächliche Ausgabe, die ich erhalte, ist jedoch nur:

1. Abfrage 1: a

Können Sie mir helfen zu verstehen, warum das passiert und wie ich es beheben kann?

import getch
import threading

QUERY = ""
EXIT_THREAD = False
def input_thread():
    global EXIT_THREAD
    last_query = ""
    while not EXIT_THREAD:
        if last_query != QUERY:
            last_query = QUERY
            print(f"Query: {QUERY}")

thread = threading.Thread(target=input_thread)
thread.start()
while True:
    char = getch.getch()
    if char == "\n":
        break
    elif char == "\x7f":
        QUERY = QUERY[:-1]
    else:
        QUERY += char
    print(f"Query1: {QUERY}")
# kill input thread
EXIT_THREAD = True
thread.join()

Richtige Antwort

Die Frage ist getch 模块编码很差。当它阻塞等待输入时，它不会释放gil（全局解释器锁），因此您的其他线程不允许运行。与锁同步并没有多大帮助； gil 已保护对 query Zugang.

Das Problem ist, dass jede Änderung query 后，您都会返回到 getch，这会锁定 gil。当 getch 返回时，已经过去了足够的时间，gil 立即被移交，另一个线程检查更改，看到最后的更改并报告它，主线程最终得到返回控制权，但通常在 getch 再次锁定它之前没有做足够的事情来导致另一次 gil 切换，并且另一个线程永远没有机会运行并看到更改，直到 getch beim nächsten Mal wiederkehrt. Dies kann je nach Python-Version variieren (die Regeln zur Überprüfung von Gil ändern sich von Zeit zu Zeit), ist aber immer instabil.

Die richtige Lösung besteht darin, getch 模块在进行阻塞调用之前在内部释放 gil，但如果做不到这一点，您可以通过在每个 getch 之前故意以 gil 释放方式阻塞来给其他线程一些运行时间调用时，通过导入 time das Modul zu öffnen und einen Ruhezustand hinzuzufügen, um anderen Threads Zeit zu geben, die neuesten Änderungen zu sehen:

while True:
    time.sleep(0.001)  # Explicitly releases GIL for a millisecond
    char = getch.getch()

Dies führt zu dem erwarteten Verhalten, obwohl es technisch gesehen den Rennbedingungen unterliegt, wenn andere Threads beteiligt sind, aber für zwei Threads wie diesen ist es ziemlich zuverlässig.

Das obige ist der detaillierte Inhalt vonWarum sind Änderungen, die ein Thread an gemeinsam genutzten Variablen vornimmt, für andere Threads in Python unsichtbar?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!