I'm working on a project in Python using the "thread" module.
How can I make a global variable (in my case I need it to be True or False) that all the threads in my project (about 4-6) can access?
You can protect data variables shared between threads using a threading. Lock mutex lock, and you can share data between threads explicitly using queue. Queue.
You should use volatile keyword to keep the variable updated among all threads. Using volatile is yet another way (like synchronized, atomic wrapper) of making class thread safe. Thread safe means that a method or class instance can be used by multiple threads at the same time without any problem.
Tip: Unlike class and instance field variables, threads cannot share local variables and parameters. The reason: Local variables and parameters allocate on a thread's method-call stack. As a result, each thread receives its own copy of those variables.
Even though the variable is not currently being written to, previous writes to the variable may not yet be visible to all threads. This means two threads can read the same value and get different results creating a race condition.
We can define the variable outside the thread classes and declare it global inside the methods of the classes.
Please see below trivial example which prints AB alternatively. Two variables flag
and val
are shared between two threads Thread_A
and Thread_B
. Thread_A
prints val=20
and then sets val
to 30. Thread_B
prints val=30
, since val
is modified in Thread_A
. Thread_B
then sets val
to 20 which is again used in Thread_A
. This demonstrates that variable val
is shared between two threads. Similarly variable flag
is also shared between two threads.
import threading import time c = threading.Condition() flag = 0 #shared between Thread_A and Thread_B val = 20 class Thread_A(threading.Thread): def __init__(self, name): threading.Thread.__init__(self) self.name = name def run(self): global flag global val #made global here while True: c.acquire() if flag == 0: print "A: val=" + str(val) time.sleep(0.1) flag = 1 val = 30 c.notify_all() else: c.wait() c.release() class Thread_B(threading.Thread): def __init__(self, name): threading.Thread.__init__(self) self.name = name def run(self): global flag global val #made global here while True: c.acquire() if flag == 1: print "B: val=" + str(val) time.sleep(0.5) flag = 0 val = 20 c.notify_all() else: c.wait() c.release() a = Thread_A("myThread_name_A") b = Thread_B("myThread_name_B") b.start() a.start() a.join() b.join()
Output looks like
A: val=20 B: val=30 A: val=20 B: val=30 A: val=20 B: val=30 A: val=20 B: val=30
Each thread prints the value which was modified in another thread.
With no clue as to what you are really trying to do, either go with nio's approach and use locks, or consider condition variables:
From the docs
# Consume one item cv.acquire() while not an_item_is_available(): cv.wait() get_an_available_item() cv.release() # Produce one item cv.acquire() make_an_item_available() cv.notify() cv.release()
You can use this to let one thread tell another a condition has been met, without having to think about the locks explicitly. This example uses cv
to signify that an item is available.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With