Python多处理-进程数

我正在执行下面的代码，它工作得很好，但它并不是派生到不同的进程，而是有时所有的进程都运行在同一个进程中，有时是一个进程中的两个。我用的是一台4 cpu的机器。这个代码有什么问题

def f(values):
    print(multiprocessing.current_process())
    return values

def main():
    p = Pool(4) #number of processes = number of CPUs
    keys, values= zip(*data.items()) #ordered keys and values
    processed_values= p.map( f, values )
    result= dict( zip(keys, processed_values ) ) 
    p.close() # no more tasks
    p.join()  # wrap up current tasks

结果是

<SpawnProcess(SpawnPoolWorker-1, started daemon)>
<SpawnProcess(SpawnPoolWorker-1, started daemon)>
<SpawnProcess(SpawnPoolWorker-1, started daemon)>
<SpawnProcess(SpawnPoolWorker-1, started daemon)>

有时候像这样

<SpawnProcess(SpawnPoolWorker-3, started daemon)>
<SpawnProcess(SpawnPoolWorker-2, started daemon)>
<SpawnProcess(SpawnPoolWorker-1, started daemon)>
<SpawnProcess(SpawnPoolWorker-3, started daemon)>

有时候

<SpawnProcess(SpawnPoolWorker-1, started daemon)>
<SpawnProcess(SpawnPoolWorker-4, started daemon)>
<SpawnProcess(SpawnPoolWorker-2, started daemon)>
<SpawnProcess(SpawnPoolWorker-1, started daemon)>

---

我的问题是，它在什么基础上将功能分配给工人？我编写代码的方式是，它根据字典中的键数决定进程数（考虑到我的数据总是比我的CPU的键数少）。我的代码将像这样开始-主代码读取文件并使用单个进程生成字典，应该将其分支到多个并发进程并等待它们处理数据（我使用pool.map），然后一旦它得到子进程的结果，它就开始处理它们。如何实现父进程等待子进程步骤？

您的代码没有问题。您的工作项非常快—如此之快，以至于同一个工作进程可以运行函数，返回结果，然后赢得竞赛，从内部队列中使用下一个任务，该队列是

多处理.Pool

用来分配工作的。当您调用

map

时，工作项将被分为多个批并放入

队列中。下面是
pool.map
实现的一部分，它将iterable中的项分块并放入队列：

    task_batches = Pool._get_tasks(func, iterable, chunksize)
    result = MapResult(self._cache, chunksize, len(iterable), callback)
    self._taskqueue.put((((result._job, i, mapstar, (x,), {}) 
                          for i, x in enumerate(task_batches)), None))

每个工作进程运行一个具有无限while循环的函数，该循环使用该队列中的项目*：

while maxtasks is None or (maxtasks and completed < maxtasks):
    try:
        task = get()  # Pulls an item off the taskqueue
    except (EOFError, IOError):
        debug('worker got EOFError or IOError -- exiting')
        break

    if task is None:
        debug('worker got sentinel -- exiting')
        break

    job, i, func, args, kwds = task
    try:
        result = (True, func(*args, **kwds))  # Runs the function you passed to map
    except Exception, e:
        result = (False, e)
    try:
        put((job, i, result))  # Sends the result back to the parent
    except Exception as e:
        wrapped = MaybeEncodingError(e, result[1])
        debug("Possible encoding error while sending result: %s" % (
            wrapped))

*这实际上并不完全正确-有一个线程在主进程中运行，它从
任务队列
中消耗，然后将它提取的内容粘贴到另一个
队列
，这就是子进程从中消耗的内容）
很酷，这只是为了测试，对于我稍后使用的大型数据集，我在函数中的计算量将很高。关于我问题的最后一部分，如何实现这一点我的代码将像这样开始-主代码读取文件并使用单个进程生成字典，应该将其分支到多个并发进程并等待它们处理数据（我使用pool.map），然后一旦它得到子进程的结果，它就开始处理它们。如何实现此父进程等待子进程步骤？@Jeeva
pool.map
将不会返回，直到您传递的iterable（
data
，在您的示例中）中的所有项都已由子进程处理。示例中的
processed_values
列表将包含每次执行
f
的结果。因此，您不需要做比您已经做的更多的事情。问题是-task\u batches=Pool.\u get\u tasks（func、iterable、chunksize），我希望我的函数应用于字典中的每个键。它不是一个确定的大小。所以基本上我的字典中的n_进程=n_键。中n_键时间的相同功能parallel@Jeeva当您有一个大的iterable时，分块只是用来加速进程间的通信。在您的示例中，chunksize将是
1
，因此每个任务将单独排队。@Jeeva而且即使任务是分块发送的，您的函数仍将在
数据中的每个项目上单独运行，并且您从
映射中得到的结果仍将为
数据中的每个项目包含一个结果。
chunksize
实际上只是一个实现细节，您可以出于性能原因对其进行调整。
def f(values):
    print(multiprocessing.current_process())
    time.sleep(1)
    return values