如何在多线程情况下使用python线程锁定模块

Question

I was trying to lock a function by using python threading.Lock() , but things not happened as I expected.

#!/usr/bin/python
# -*- coding:utf-8 -*-

import time
import threading
# mutex = threading.Lock()


def within_mutex():
    print "###########in mutex############"
    n = 0
    while n<5:
        print "waiting ...", n
        n += 1
        time.sleep(1)
    print "##########end mutex############"

def check_thread(lock):
    print "~~~~~~~~~~~in thread~~~~~~~~~~~~"
    print "=====before mutex======", lock.locked()
    with lock:
        print "get mutex, trigger a new thread"
        print "=====in mutex======", lock.locked()
        within_mutex()
    print "=====after mutex======", lock.locked()
    print "~~~~~~~~~~~end thread~~~~~~~~~~~~"

def thread_test(lock):
    if not lock.locked():
        thread1 = threading.Thread(target=check_thread, args=(lock))
        thread1.start()
    print "End thread_test"
    return 11

if __name__ == '__main__':
    lock = threading.Lock()
    t1 = thread_test(lock)
    t2 = thread_test(lock)
    print "t1 = ",t1
    print "t2 = ",t2

As code showed above, I was trying to pass a lock to a thread test function thread_test() , which should trigger a new thread check_thread if lock was not acquired, otherwise should return result (that is 11) immediately.

In my opinion, in main function, t1 = thread_test(lock) should triggered a new thread, and went into check_thread , and t2 = thread_test(lock) should NOT trigger a new thread, t2 = thread_test(lock) should just return 11 directly.

However, two threads were triggered, and I don't know why? It seemd that lock.locked() not working or in check_thread function, with lock module not working.

And, How can I fix this as I only want to trigger ONE thread in this case, How can I get with lock work?

result of above code:

End thread_test
~~~~~~~~~~~in thread~~~~~~~~~~~~
=====before mutex====== False
get mutex, trigger a new thread
=====in mutex====== True
###########in mutex############
waiting ... 0
End thread_test
t1 =  11
t2 =  11
~~~~~~~~~~~in thread~~~~~~~~~~~~
=====before mutex====== True
waiting ... 1
waiting ... 2
waiting ... 3
waiting ... 4
##########end mutex############
=====after mutex====== True
~~~~~~~~~~~end thread~~~~~~~~~~~~
get mutex, trigger a new thread
=====in mutex====== True
###########in mutex############
waiting ... 0
waiting ... 1
waiting ... 2
waiting ... 3
waiting ... 4
##########end mutex############
=====after mutex====== False
~~~~~~~~~~~end thread~~~~~~~~~~~~
[Finished in 10.8s]

Answer 1

What is happening:

1. thread1 says lock is free
2. thread2 says lock is free (before thread1 manages to acquire lock)
3. thread1 enters the with lock , thus acquiring the lock
4. thread2 also enters with lock - it internally tries calling lock.acquire - and the default behaviour is to wait for the lock to be freed up. Since lock is already blocked by thread1, thread2 is forced to wait for completion.
5. That's why both of them run, even though you try checking if lock.locked() (notice that your current code will sporadically run only one thread)

Solution:

Instead of relying on with lock , use explicit lock.acquire(False) and then lock.release() once you're done with execution.

Passing the parameter False will change the default behaviour of acquiring locks (see documentation )