Python 有没有办法在嵌套函数或模块中使用multiprocessing.pool？

谢谢你看这个。我承认我已经在python中涉猎并行处理一周了，所以如果有一个明显的解决方案我错过了，我道歉。我有一段代码，我想运行mp.pool（）的几个不同实例。那些位于名为的主.py文件中的文件工作得很好，但是当我尝试将它们添加到模块中的函数时，我没有从它们中得到任何输出。应用程序只是从它旁边跑过去并继续运行。我认为这可能与此有关，但它没有给出任何其他方法来完成我需要的想法。在一个简单示例中工作的代码如下：

import multiprocessing as mp
def multiproc_log_result(retval):
    results.append(retval)
    if len(results) % (10 // 10) == 0:
        print('{0}% done'.format(100 * len(results) / 10))

def meat():
    print 'beef'
    status = True
    return status
results = []
pool = mp.Pool(thread_count)
for x in range(10):
    pool.apply_async(meat, callback=multiproc_log_result)
pool.close()
pool.join()


def veggie():
    print 'carrot'
    status = True
    return status

results = []
pool = mp.Pool(thread_count)
for x in range(10):
    pool.apply_async(veggie, callback=multiproc_log_result)
pool.close()
pool.join()

不起作用的代码是：

import multiprocessing as mp
def multiproc_log_result(retval):
    results.append(retval)
    if len(results) % (10 // 10) == 0:
        print('{0}% done'.format(100 * len(results) / 10))

def meat():
    print 'beef'
    status = True
    return status
results = []
pool = mp.Pool(thread_count)
for x in range(10):
    pool.apply_async(meat, callback=multiproc_log_result)
pool.close()
pool.join()

def nested_stupid_fn():
    def multiproc_log_result(retval):
        results.append(retval)
        if len(results) % (10 // 10) == 0:
            print('{0}% done'.format(100 * len(results) / 10))

    def veggie():
        print 'carrot'
        status = True
        return status

    results = []
    pool = mp.Pool(thread_count)
    for x in range(10):
        pool.apply_async(veggie, callback=multiproc_log_result)
    pool.close()
    pool.join()
nested_stupid_fn()

---

最终，我希望这个不起作用的示例通过将其放在单独模块中的另一个函数中，再删除一步。因此，当我导入模块packngo并将其用作packngo.basic_packngo（inputs）并在其中某个地方运行嵌套函数的内容时。任何帮助都将不胜感激我是一个非常简单的人，所以如果你能像对孩子那样解释，也许我会沉醉其中

我认为问题在于，在

multiproc\u log\u result

的范围内，变量

results

不存在。 因此，您应该直接将异步调用的结果附加到结果中。 但是，您将无法跟踪进度（我想没有办法在类之外直接共享回调函数的全局变量）

---

您链接的另一个问题有解决方案，只是没有详细说明：您不能使用嵌套函数作为

apply*

/

/
*map*
多处理.Pool

上的方法系列的

func

参数。它们适用于

多处理.dummy.Pool

，因为

多处理.dummy

由线程支持，线程可以直接传递函数引用，但是

多处理.Pool

必须对函数进行pickle，并且只能对具有可导入名称的函数进行pickle。如果检查嵌套函数的名称，它类似于

modulename.outerfuncname..innerfuncname

，并且

组件使其无法导入（这通常是一件好事；利用嵌套的嵌套函数通常在闭包作用域中具有临界状态，仅导入就会丢失）

以嵌套方式定义

回调

函数非常好，因为它们是在父进程中执行的，不会发送给工作进程。在您的情况下，只有回调依赖于闭包作用域，因此将

func

（

veggie

）移出到全局作用域是完全正确的，将

packngo

模块定义为：

def veggie():
    print 'carrot'
    status = True
    return status

def nested_stupid_fn():
    def multiproc_log_result(retval):
        results.append(retval)
        if len(results) % (10 // 10) == 0:
            print('{0}% done'.format(100 * len(results) / 10))

    results = []
    pool = mp.Pool(thread_count)
    for x in range(10):
        pool.apply_async(veggie, callback=multiproc_log_result)
    pool.close()
    pool.join()
nested_stupid_fn()

---

是的，这意味着

veggie

成为相关模块的公共成员。如果您想指出它应该被视为一个实现细节，可以在它前面加一个下划线（

\u veggie

），但它必须是全局性的，才能与

多处理.Pool

一起使用。我要指出的是，一些代码像multiproc\u log\u result一样被删除了，而目前它实际上没有做什么。这只是一种快速/肮脏的简化和测试方法，以隔离问题发生的地方。谢谢你的想法，但我不认为这是导致问题的原因。我可以完全删除状态跟踪的回调，但它仍然不会实际执行任何操作（在本例中，打印“carrot”十次，但在实际示例中，使用shutil移动文件）？我还通过线程池来更改池，它在我的机器上工作。无论如何，它不会打印胡萝卜，因为您分离的线程将无法在console@GabrielSamain：线程池之所以能工作，是因为将函数发送给线程工作线程不需要酸洗，而将函数发送给进程工作线程则需要酸洗。嵌套函数没有可导入名称，只能对具有全局可导入名称的函数进行pickle。

def veggie():
    print 'carrot'
    status = True
    return status

def nested_stupid_fn():
    def multiproc_log_result(retval):
        results.append(retval)
        if len(results) % (10 // 10) == 0:
            print('{0}% done'.format(100 * len(results) / 10))

    results = []
    pool = mp.Pool(thread_count)
    for x in range(10):
        pool.apply_async(veggie, callback=multiproc_log_result)
    pool.close()
    pool.join()
nested_stupid_fn()