在Python中正确使用互斥锁

Question

我从python中的多线程开始（或者至少我的脚本可能创建多个线程）。这个算法是互斥锁的正确用法吗？我还没有测试过这段代码，它可能根本就不起作用。我只想让processData在一个线程中运行（一次一个），而main while循环继续运行，即使队列中有线程。

from threading import Thread
from win32event import CreateMutex
mutex = CreateMutex(None, False, "My Crazy Mutex")
while(1)
    t = Thread(target=self.processData, args=(some_data,))
    t.start()
    mutex.lock()

def processData(self, data)
    while(1)
        if mutex.test() == False:
            do some stuff
            break

编辑：重新阅读我的代码，我可以看到它是严重错误的。但嘿，这就是我来这里寻求帮助的原因。

Answer 1

这就是我想出的解决办法：

import time
from threading import Thread
from threading import Lock

def myfunc(i, mutex):
    mutex.acquire(1)
    time.sleep(1)
    print "Thread: %d" %i
    mutex.release()


mutex = Lock()
for i in range(0,10):
    t = Thread(target=myfunc, args=(i,mutex))
    t.start()
    print "main loop %d" %i

输出：

main loop 0
main loop 1
main loop 2
main loop 3
main loop 4
main loop 5
main loop 6
main loop 7
main loop 8
main loop 9
Thread: 0
Thread: 1
Thread: 2
Thread: 3
Thread: 4
Thread: 5
Thread: 6
Thread: 7
Thread: 8
Thread: 9

Answer 2

我不知道为什么要使用窗口的互斥锁而不是Python的互斥锁

from threading import Thread, Lock

mutex = Lock()

def processData(data):
    mutex.acquire()
    try:
        print('Do some stuff')
    finally:
        mutex.release()

while True:
    t = Thread(target = processData, args = (some_data,))
    t.start()

但是请注意，由于CPython的体系结构（即Global Interpreter Lock），实际上一次只能有一个线程在运行——如果有许多线程是I/O绑定的，这是很好的，尽管您希望尽可能释放锁，以便I/O绑定的线程不会阻止其他线程运行。

对于Python2.6和更高版本，另一种选择是使用Python的multiprocessing包。它镜像了threading包，但将创建全新的进程，这些进程可以同时运行。更新示例很简单：

from multiprocessing import Process, Lock

mutex = Lock()

def processData(data):
    with mutex:
        print('Do some stuff')

if __name__ == '__main__':
    while True:
        p = Process(target = processData, args = (some_data,))
        p.start()

Answer 3

你必须在某个时候解锁你的互斥锁。。。