python：多处理管理

使用多处理python库，我可以启动多处理，如

import multiprocessing as mu

def worker(n)
        print "worker:", n
        n = int(1e4)
        for i in range(n):
                for j in range(n):
                        i*j 
        return

if __name__ == '__main__':
        jobs = []
        for i in range(5):
                p = mu.Process(target=worker, args=(i,))
                jobs.append(p)
                p.start()

我可以用

但是，如果我有一个进程列表，如何在不向处理器过度收费的情况下启动？
如果我有一个四核，我如何启动前4个进程？当完成一个过程时，启动另一个

工具书类

---

我建议避开这个问题，使用

多处理.Pool

（，）
（根据文档中的示例进行修改）
或者，您可以设置生产者/消费者方案，并拥有固定数量的长时间运行的子进程
第三种快速而肮脏的方法是使用一个

mu.Queue

。请注意，

get

阻塞，直到返回结果

import multiprocessing as mu
import time
res = mu.Queue()

def worker(n):
    print "worker:", n
    time.sleep(1)
    res.put(n)
    return

if __name__ == '__main__':
    jobs = []
    np = mu.cpu_count()
    print np
    # start first round
    for j in range(np):
        p = mu.Process(target=worker, args=(j,))
        jobs.append(p)
        p.start()
    # every time one finishes, start the next one
    for i in range(np,15):
        r = res.get()
        print 'res', r
        p = mu.Process(target=worker, args=(i,))
        jobs.append(p)
        p.start()
    # get the remaining processes 
    for j in range(np):
        r = res.get()
        print 'res', r

我提出这个解决方案

import multiprocessing as mu

def worker(n):
        print "worker:", n
        n = int(1e4/2)
        for i in range(n):
                for j in range(n):
                        i*j
        return

if __name__ == '__main__':
        jobs = []
        for i in range(5):
                p = mu.Process(target=worker, args=(i,))
                jobs.append(p)

        running = []
        np = mu.cpu_count()

        for i in range(np):
                p = jobs.pop()
                running.append(p)
                p.start()

        while jobs != []:
                for r in running:
                        if r.exitcode == 0:
                                running.remove(r)
                                p = jobs.pop()
                                p.start()
                                running.append(p)

---

我知道pool.map，但我的问题更多的是，如何管理流程？也许有了

.is_alive（）

这个关于

进程的关键词：“如果
进程
是
无
，那么就使用
cpu_count（）
返回的数字”所以你对
num_proc
的建议是默认情况下会发生的。@martineau很公平，但把事情说得明白一点也没有坏处（我被系统/版本之间不同的默认行为（主要是
matplotlib
样式设置）所困扰）我认为您将在最后一个
np
进程完成之前杀死它们。主进程将在清空
作业后完成，并且不会等待子进程完成。
import multiprocessing as mu
import time
res = mu.Queue()

def worker(n):
    print "worker:", n
    time.sleep(1)
    res.put(n)
    return

if __name__ == '__main__':
    jobs = []
    np = mu.cpu_count()
    print np
    # start first round
    for j in range(np):
        p = mu.Process(target=worker, args=(j,))
        jobs.append(p)
        p.start()
    # every time one finishes, start the next one
    for i in range(np,15):
        r = res.get()
        print 'res', r
        p = mu.Process(target=worker, args=(i,))
        jobs.append(p)
        p.start()
    # get the remaining processes 
    for j in range(np):
        r = res.get()
        print 'res', r

import multiprocessing as mu

def worker(n):
        print "worker:", n
        n = int(1e4/2)
        for i in range(n):
                for j in range(n):
                        i*j
        return

if __name__ == '__main__':
        jobs = []
        for i in range(5):
                p = mu.Process(target=worker, args=(i,))
                jobs.append(p)

        running = []
        np = mu.cpu_count()

        for i in range(np):
                p = jobs.pop()
                running.append(p)
                p.start()

        while jobs != []:
                for r in running:
                        if r.exitcode == 0:
                                running.remove(r)
                                p = jobs.pop()
                                p.start()
                                running.append(p)