使用multiprocessing.Process并发进程数最多

Question 1

我有Python代码：

from multiprocessing import Process

def f(name):
    print 'hello', name

if __name__ == '__main__':
    for i in range(0, MAX_PROCESSES):
        p = Process(target=f, args=(i,))
        p.start()

运行良好。但是，MAX_PROCESSES是变量，可以是1和之间的任何值512。由于我仅在具有8内核的计算机上运行此代码，因此我需要确定是否有可能限制允许同时运行的进程数。我已经调查过了multiprocessing.Queue，但看起来不像我需要的东西-也许我在错误地解释了文档。

有没有一种方法可以限制同时multiprocessing.Process运行的数量？

Question 2

可能最明智的做法是multiprocessing.Pool根据系统上可用的最大内核数来生成工作进程池，然后在内核可用时基本上提供任务。

标准文档（http://docs.python.org/2/library/multiprocessing.html#using-a-pool-of-workers）中的示例显示，您还可以手动设置核数：

from multiprocessing import Pool

def f(x):
    return x*x

if __name__ == '__main__':
    pool = Pool(processes=4)              # start 4 worker processes
    result = pool.apply_async(f, [10])    # evaluate "f(10)" asynchronously
    print result.get(timeout=1)           # prints "100" unless your computer is *very* slow
    print pool.map(f, range(10))          # prints "[0, 1, 4,..., 81]"

而且multiprocessing.cpu_count()，如果代码中需要的话，也很容易知道有一种方法可以计算给定系统上的内核数。

编辑：这是一些看起来适合您的特定情况的代码草案：

import multiprocessing

def f(name):
    print 'hello', name

if __name__ == '__main__':
    pool = multiprocessing.Pool() #use all available cores, otherwise specify the number you want as an argument
    for i in xrange(0, 512):
        pool.apply_async(f, args=(i,))
    pool.close()
    pool.join()

Question 3

我认为Semaphore是您正在寻找的东西，它将在递减为0时阻止主进程。示例代码：

from multiprocessing import Process
from multiprocessing import Semaphore
import time

def f(name, sema):
    print('process {} starting doing business'.format(name))
    # simulate a time-consuming task by sleeping
    time.sleep(5)
    # `release` will add 1 to `sema`, allowing other 
    # processes blocked on it to continue
    sema.release()

if __name__ == '__main__':
    concurrency = 20
    total_task_num = 1000
    sema = Semaphore(concurrency)
    all_processes = []
    for i in range(total_task_num):
        # once 20 processes are running, the following `acquire` call
        # will block the main process since `sema` has been reduced
        # to 0. This loop will continue only after one or more 
        # previously created processes complete.
        sema.acquire()
        p = Process(target=f, args=(i, sema))
        all_processes.append(p)
        p.start()

    # inside main process, wait for all processes to finish
    for p in all_processes:
        p.join()

由于以下代码sema在同一函数中获取和释放，因此其结构更加结构化。但是，如果total_task_num非常大，它将消耗太多资源：

from multiprocessing import Process
from multiprocessing import Semaphore
import time

def f(name, sema):
    print('process {} starting doing business'.format(name))
    # `sema` is acquired and released in the same
    # block of code here, making code more readable,
    # but may lead to problem.
    sema.acquire()
    time.sleep(5)
    sema.release()

if __name__ == '__main__':
    concurrency = 20
    total_task_num = 1000
    sema = Semaphore(concurrency)
    all_processes = []
    for i in range(total_task_num):
        p = Process(target=f, args=(i, sema))
        all_processes.append(p)
        # the following line won't block after 20 processes
        # have been created and running, instead it will carry 
        # on until all 1000 processes are created.
        p.start()

    # inside main process, wait for all processes to finish
    for p in all_processes:
        p.join()

上面的代码将创建total_task_num进程，但是只有concurrency进程将运行，而其他进程被阻止，这将消耗宝贵的系统资源。

Question 4

更一般地，它也可能看起来像这样：

import multiprocessing
def chunks(l, n):
    for i in range(0, len(l), n):
        yield l[i:i + n]

numberOfThreads = 4


if __name__ == '__main__':
    jobs = []
    for i, param in enumerate(params):
        p = multiprocessing.Process(target=f, args=(i,param))
        jobs.append(p)
    for i in chunks(jobs,numberOfThreads):
        for j in i:
            j.start()
        for j in i:
            j.join()

当然，这种方式非常残酷（因为它等待垃圾中的每个进程，直到它继续下一个块为止）。在函数调用的运行时间大致相等的情况下，它仍然可以正常工作。