Python多处理锁

Question

此多处理代码按预期工作.它创建了4个Python进程,并使用它们打印数字0到39,每次打印后都会有延迟.

import multiprocessing
import time

def job(num):
  print num
  time.sleep(1)

pool = multiprocessing.Pool(4)

lst = range(40)
for i in lst:
  pool.apply_async(job, [i])

pool.close()
pool.join()

但是,当我尝试使用multiprocessing.Lock来防止多个进程从打印到标准输出时,程序只是立即退出而没有任何输出.

import multiprocessing
import time

def job(lock, num):
  lock.acquire()
  print num
  lock.release()
  time.sleep(1)

pool = multiprocessing.Pool(4)
l = multiprocessing.Lock()

lst = range(40)
for i in lst:
  pool.apply_async(job, [l, i])

pool.close()
pool.join()

为什么引入multiprocessing.Lock会使这段代码不起作用？

更新:当全局声明锁时(我在那里做了一些非确定性测试以检查锁是否正常),而不是上面的代码将锁作为参数传递(Python的多处理文档显示锁被传递为参数).下面的代码具有全局声明的锁,而不是在上面的代码中作为参数传递.

import multiprocessing
import time

l = multiprocessing.Lock()

def job(num):
  l.acquire()
  print num
  l.release()
  time.sleep(1)

pool = multiprocessing.Pool(4)

lst = range(40)
for i in lst:
  pool.apply_async(job, [i])

pool.close()
pool.join()

Answer 1

其他答案已经提供了答案，除非提供apply_async适当的论据，否则会默默失败。error_callback我仍然发现OP的另一点是有效的——官方文档确实显示multiprocessing.Lock了作为函数参数传递。事实上，编程指南中标题为“显式地将资源传递给子进程”的小节建议将multiprocessing.Lock对象作为函数参数而不是全局变量传递。而且，我一直在编写大量代码，其中我将 amultiprocessing.Lock作为参数传递给子进程，并且一切都按预期工作。

那么，什么给出呢？

我首先调查了是否multiprocessing.Lock可以腌制。在Python 3、MacOS+CPython中，尝试pickle会产生其他人遇到的multiprocessing.Lock熟悉情况。RuntimeError

>>> pickle.dumps(multiprocessing.Lock())
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-7-66dfe1355652> in <module>
----> 1 pickle.dumps(multiprocessing.Lock())

/usr/local/Cellar/python/3.7.3/Frameworks/Python.framework/Versions/3.7/lib/python3.7/multiprocessing/synchronize.py in __getstate__(self)
     99
    100     def __getstate__(self):
--> 101         context.assert_spawning(self)
    102         sl = self._semlock
    103         if sys.platform == 'win32':

/usr/local/Cellar/python/3.7.3/Frameworks/Python.framework/Versions/3.7/lib/python3.7/multiprocessing/context.py in assert_spawning(obj)
    354         raise RuntimeError(
    355             '%s objects should only be shared between processes'
--> 356             ' through inheritance' % type(obj).__name__
    357             )

RuntimeError: Lock objects should only be shared between processes through inheritance

对我来说，这证实了它multiprocessing.Lock确实不可腌制。

旁白开始

但是，同一个锁仍然需要在两个或多个 python 进程之间共享，这些进程将有自己的、可能不同的地址空间（例如当我们使用“spawn”或“forkserver”作为启动方法时）。multiprocessing必须做一些特殊的事情来跨进程发送锁。StackOverflow 的另一篇文章似乎表明，在 Unix 系统中，multiprocessing.Lock可以通过操作系统本身（Python 之外）支持的命名信号量来实现。然后，两个或多个 python 进程可以链接到同一个锁，该锁实际上驻留在两个 python 进程之外的一个位置。也可能有共享内存的实现。

一边结束

我们可以将multiprocessing.Lock对象作为参数传递吗？

经过几次更多的实验和更多的阅读，看来差异在于multiprocessing.Pool和之间multiprocessing.Process。

multiprocessing.Process让您multiprocessing.Lock作为参数传递，但multiprocessing.Pool不这样做。这是一个有效的示例：

import multiprocessing
import time
from multiprocessing import Process, Lock


def task(n: int, lock):
    with lock:
        print(f'n={n}')
    time.sleep(0.25)


if __name__ == '__main__':
    multiprocessing.set_start_method('forkserver')
    lock = Lock()
    processes = [Process(target=task, args=(i, lock)) for i in range(20)]
    for process in processes:
        process.start()
    for process in processes:
        process.join()

请注意，如编程指南__name__ == '__main__'的“安全导入主模块”小节中所述，使用是必不可少的。

multiprocessing.Pool似乎使用queue.SimpleQueue它将每个任务放入队列中，这就是酸洗发生的地方。最有可能的是，multiprocessing.Process不使用酸洗（或进行特殊版本的酸洗）。

Answer 2

如果更改pool.apply_async为pool.apply,则会出现以下异常:

Traceback (most recent call last):
  File "p.py", line 15, in <module>
    pool.apply(job, [l, i])
  File "/usr/lib/python2.7/multiprocessing/pool.py", line 244, in apply
    return self.apply_async(func, args, kwds).get()
  File "/usr/lib/python2.7/multiprocessing/pool.py", line 558, in get
    raise self._value
RuntimeError: Lock objects should only be shared between processes through inheritance

pool.apply_async只是隐藏它.我讨厌这样说,但使用全局变量可能是你的例子最简单的方法.让我们只希望快速变形金刚不会得到你.

Answer 3

我认为原因是多处理池用于pickle在进程之间传输对象。但是，Lock不能腌制：

>>> import multiprocessing
>>> import pickle
>>> lock = multiprocessing.Lock()
>>> lp = pickle.dumps(lock)
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    lp = pickle.dumps(lock)
...
RuntimeError: Lock objects should only be shared between processes through inheritance
>>> 

请参阅“Picklability”和“更好的继承不是泡菜/ unpickle”的部分https://docs.python.org/2/library/multiprocessing.html#all-platforms