Python threading Lock not working in simple example

Question

I must be missing something here but this simple example of two threads trying to modify a global variable in a function is not giving the expected result:

from threading import Thread, Lock
some_var = 0

def some_func(id):
    lo = Lock()
    with lo:
        global some_var
        print("{} here!".format(id))
        for i in range(1000000):
            some_var += 1
        print("{} leaving!".format(id))


t1 = Thread(target=some_func, args=(1,))
t2 = Thread(target=some_func, args=(2,))
t1.start()
t2.start()
t1.join()
t2.join()
print(some_var)

outputs:

1 here!
2 here!
2 leaving!
1 leaving!
1352010

As you can see both threads enter the part that should be locked simultaneous and the incrementation of the globel variable 'some_var' gets mixed up because of that.

It looks like the Lock is just not working for some reason. For a range up to 10000 it is working but this is probably just because of the GIL not being released during such short calculations.

What is going on?

I'm using Python3.3.2 64bit

Answer 1

The Lock() function creates an entirely new lock - one that only the thread calling the function can use. That's why it doesn't work, because each thread is locking an entirely different lock.

Lock items are one of the few things that you can declare as a global without any problems, because you absolutely want every thread to see the same Lock(). You should try this instead:

from threading import Thread, Lock
some_var = 0
lo = Lock()

def some_func(id):
    global lo
    with lo:
        global some_var
        print("{} here!".format(id))
        for i in range(1000000):
            some_var += 1
        print("{} leaving!".format(id))