Why are changes made to shared variables by one thread invisible to other threads in Python?

Question content

I tried using the same variable in multiple threads, but the value of the variable was not updated consistently across threads. For example, when thread 1 updates a variable to 1, thread 2 does not recognize this change and instead sees the old value.

This is a simple code example illustrating the problem. When the user presses the "a" key, the variable "query" should update and display like this:

1. Query 1: a
2. Query: a

However, the actual output I get is just:

1. Query 1: a

Can you help me understand why this is happening and how to fix it?

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()

Correct answer

The problem is that the getch module is poorly coded. While it blocks waiting for input, it does not release the gil (global interpreter lock), so your other threads are not allowed to run. Synchronizing with the lock doesn't help much; gil has protected access to query.

The problem is that every time you change query, you're back to getch, which locks the gil. When getch returns, enough time has passed that the gil is immediately handed over, another thread checks for changes, sees the last change and reports it, and the main thread eventually gets control back, but usually after getch Not enough is done before locking it again to cause another gil switch, and another thread never gets a chance to run and see the changes until getch returns next time. This may vary depending on the python version (the rules for checking gil change from time to time), but it's always unstable.

The correct solution is for the getch module to release the gil internally before making blocking calls, but failing that you can do this by deliberately prefixing each getch with When calling gil release mode blocking to give other threads some running time, import the time module and add a sleep to give other threads time to view the latest changes:

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

This gets the behavior you expect, although technically you're subject to a race condition if other threads are involved, but for two threads like this it's pretty reliable.

The above is the detailed content of Why are changes made to shared variables by one thread invisible to other threads in Python?. For more information, please follow other related articles on the PHP Chinese website!