Python creating a shared variable between threads

Question

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?

What are you actually trying to do? If you want some kind of "keepRunning" variable, there might be better ways than a global — doctorlove, Jul 21 '13 at 17:39
What have you tried? Short code examples of what didn't work are always helpful when looking for an answer to your question. — Merlyn Morgan-Graham, Jul 21 '13 at 18:04
Are you just asking how to make a global? Declare it at module level then use the `global` keyword within defs to access it. — roippi, Jul 21 '13 at 18:06
@shay: Do not use the `thread` module. Instead, use the `threading` module. — pillmuncher, Jul 21 '13 at 18:52

score 40 · Accepted Answer · edited Jan 05 '18 at 18:46

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.

why isn't `c` (the `threading.Condition()`) defined as `global`? — Shai, Jul 13 '17 at 08:01
@Shai because it's not being reassigned. It does not need to be. Flag and val on the other hand are reassigned, so should that assignment create a local variable, or modify the global one? it's ambiguous without the global keyword. But `c` is not reassigned, so it's not ambiguous. — alkasm, May 11 '20 at 06:30
Well this assumes both threads are created in the same source file, so they both have (closure-style) access to the global names doesn't it? — matanster, Jun 06 '20 at 10:29
@matanster yes, both threads should be created in the same source file. That's not an optimal solution don't know why it's the accepted one ! I am trying to find a way to do it with queues.. — BAKYAC, Jan 05 '22 at 16:10

score 9 · Answer 2 · answered Jul 21 '13 at 17:49

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.

Python creating a shared variable between threads

2 Answers2

Linked