Question

我对Python有点新鲜。我一直在学习和研究多处理模块，并且在使用锁定时遇到了这个问题。

这是测试代码：

import multiprocessing
from multiprocessing import Pool

class Param_Class():

#Initialisation.
    def __init__(self):
        self.counter = multiprocessing.Value('i',0)
        self.lock = multiprocessing.Lock()

    def inc_counter(self):
            lk.acquire()
            print('Locked {}'.format(multiprocessing.current_process().name))
            self.counter.value+=1
            lk.release()
            print('Released {}'.format(multiprocessing.current_process().name))

param_class = Param_Class()

def init(lock):
    global lk
    lk = lock


def target():
    param_class.inc_counter()
    code = 0
    return code

def handler(i):
    if i<50:
        code = target()
        print(param_class.counter.value)


if __name__ == '__main__':
    p = Pool(processes=2,initializer=init, initargs=(param_class.lock,))
    p.map_async(handler,range(50))
    p.close()
    p.join()

我期望每个进程在执行另一个进程时被锁定，因此每次执行任一进程时我的计数器都应递增。但是，进程之间没有发生互锁，而第二个进程正在处理该计数器的副本。

这是输出：

Locked SpawnPoolWorker-1
Released SpawnPoolWorker-1
1
Locked SpawnPoolWorker-1
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
2
Released SpawnPoolWorker-2
1
Locked SpawnPoolWorker-1
Locked SpawnPoolWorker-2
Released SpawnPoolWorker-1
Released SpawnPoolWorker-2
3
2
Locked SpawnPoolWorker-1
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
4
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
3
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
5
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
4
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
6
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
5
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
7
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
6
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
8
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
7
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
9
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
8
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
10
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
9
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
11
Released SpawnPoolWorker-2
10
Locked SpawnPoolWorker-1
Locked SpawnPoolWorker-2
Released SpawnPoolWorker-1
Released SpawnPoolWorker-2
12
11
Locked SpawnPoolWorker-1
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
13
Released SpawnPoolWorker-2
12
Locked SpawnPoolWorker-1
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
14
Released SpawnPoolWorker-2
13
Locked SpawnPoolWorker-1
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
15
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
14
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
16
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
15
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
17
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
16
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
18
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
17
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
19
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
18
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
20
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
19
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
21
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
20
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
22
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
21
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
23
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
22
Released SpawnPoolWorker-1
24
Locked SpawnPoolWorker-1
Released SpawnPoolWorker-1
25
Locked SpawnPoolWorker-1
Released SpawnPoolWorker-1
26
Locked SpawnPoolWorker-1
Released SpawnPoolWorker-1
27
Locked SpawnPoolWorker-1
Released SpawnPoolWorker-1
28

期望的输出应该是这样的：

Locked SpawnPoolWorker-1
1
Released SpawnPoolWorker-1
Locked SpawnPoolWorker-2
2
Released SpawnPoolWorker-2
Locked SpawnPoolWorker-1
3
Released SpawnPoolWorker-1
.
.
.
.
.
.
.
Locked SpawnPoolWorker-2
50
Released SpawnPoolWorker-2

我已提及this了解初始化锁定并继承锁定。我无法理解我搞砸了哪里。是锁定还是multiprocessing.Pool调用或使用类实例，还是目标函数本身。请用一些理论来详细说明它。我想了解这一点，而不仅仅是解决它。

请注意，在获得的输出中，它如何按预期从值24到28工作，而过程2刚刚停止工作。还需要澄清这一点。

P.S。：我想避免使用管理器，因为它是重量级的，如链接答案中所述。此外，我不想消除执行的部分并发性，因为我将使用其他不需要锁定的变量，我希望模块保持快速和pythonic。

Answer 1

显然，每次进行一次应用时，都会调用类的 init ，从而为每个进程创建一个副本。

因此要克服这一点，不是将计数器作为类属性创建，而是可以在池的init中传递并使其成为全局。

此外，锁定无关紧要。

在Python中使用多处理模块时，无法在进程之间进行互锁

1 个答案: