Python 具有不同功能的多进程池

多进程工作池的大多数示例在不同的进程中执行单个函数，例如

def foo(args):
   pass

if __name__ == '__main__':
   pool = multiprocessing.Pool(processes=30)
   res=pool.map_async(foo,args)

有没有办法处理池中两个不同且独立的函数？这样您就可以为foo（）分配f.e.15个进程，为bar（）分配15个进程，或者一个池绑定到一个函数？或者，您必须使用手动方式为不同的功能创建不同的流程

 p = Process(target=foo, args=(whatever,))
 q = Process(target=bar, args=(whatever,))
 q.start()
 p.start()

---

忘记工作池？

要传递不同的函数，只需多次调用

map\u async

这里有一个例子来说明

from multiprocessing import Pool
from time import sleep

def square(x):
    return x * x

def cube(y):
    return y * y * y

pool = Pool(processes=20)

result_squares = pool.map_async(f, range(10))
result_cubes = pool.map_async(g, range(10))

结果将是：

>>> print result_squares.get(timeout=1)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> print result_cubes.get(timeout=1)
[0, 1, 8, 27, 64, 125, 216, 343, 512, 729]

---

它们不会并行运行。 请参阅以下代码：

def updater1(q,i):    
    print "UPDATER 1:", i
    return

def updater2(q,i):    
    print "UPDATER2:", i
    return

if __name__=='__main__':
    a = range(10)
    b=["abc","def","ghi","jkl","mno","pqr","vas","dqfq","grea","qfwqa","qwfsa","qdqs"]


    pool = multiprocessing.Pool()

    func1 = partial(updater1,q)
    func2 = partial(updater2,q)
    pool.map_async(func1, a)
    pool.map_async(func2, b)

    pool.close()
    pool.join()

上述代码生成以下打印输出：

UPDATER 1: 1
UPDATER 1: 0
UPDATER 1: 2
UPDATER 1: 3
UPDATER 1: 4
UPDATER 1: 5
UPDATER 1: 6
UPDATER 1: 7
UPDATER 1: 8
UPDATER 1: 9
UPDATER2: abc
UPDATER2: def
UPDATER2: ghi
UPDATER2: jkl
UPDATER2: mno
UPDATER2: pqr
UPDATER2: vas
UPDATER2: dqfq
UPDATER2: grea
UPDATER2: qfwqa
UPDATER2: qwfsa
UPDATER2: qdqs

您可以使用map或一些lambda函数（编辑：实际上您不能使用lambda函数）。您可以使用一个简单的映射函数：

def smap(f, *args):
    return f(*args)

pool = multiprocessing.Pool(processes=30)
res=pool.map(smap, function_list, args_list1, args_list2,...)

---

normal map函数将iterables作为输入，这很不方便。

这里是@Rayamon分享的想法的一个工作示例：

import functools

from multiprocessing import Pool


def a(param1, param2, param3):
    return param1 + param2 + param3


def b(param1, param2):
    return param1 + param2


def smap(f):
    return f()


func1 = functools.partial(a, 1, 2, 3)
func2 = functools.partial(b, 1, 2)

pool = Pool(processes=2)
res = pool.map(smap, [func1, func2])
pool.close()
pool.join()
print(res)

---

为了进一步解释上述另一个答案，以下是一个示例：

使用池（方形函数）并行运行具有多个输入的单个函数有趣的一面注意“5 981 25”行中的损坏op

使用不同的输入（args和kwargs）运行多个函数，并使用池（pf1、pf2、pf3函数）收集它们的结果

多功能 下面的示例演示如何在池中运行多个函数

from multiprocessing import Pool
import functools

def inc(x):
    return x + 1

def dec(x):
    return x - 1

def add(x, y):
    return x + y

def smap(f):
    return f()

def main():

    f_inc = functools.partial(inc, 4)
    f_dec = functools.partial(dec, 2)
    f_add = functools.partial(add, 3, 4)

    with Pool() as pool:
        res = pool.map(smap, [f_inc, f_dec, f_add])
        print(res)

if __name__ == '__main__':
    main()

我们有三个函数，它们在一个池中独立运行。我们使用functools.partial在执行函数及其参数之前进行准备

---

来源：

它们是并行执行还是“一行”执行？

map\u async

会立即返回。只要池中有足够的空闲进程，新任务就可以在不必等待的情况下运行。在上面的示例中，它们将并行运行@疯狂的科学家！但我想，没有办法分配特定数量的工人/流程？没有提供在同一个池中分配特定数量工人的机制。如果您确实希望每个任务有特定数量的工作人员，请创建不同的池。尽管建议只使用一个池。我想池应该透明地为您管理这一点是有道理的，您不必担心。谢谢您的回答，您是否肯定依次添加

map\u async（）

将并行运行。事实上，我已经尝试过这个方法，正如@Sam的答案所示，这些方法似乎是按顺序运行的。这应该被认为是正确的答案，因为被接受的答案是以准并行模式运行的（有一个糟糕的计划器）。

from multiprocessing import Pool
import functools

def inc(x):
    return x + 1

def dec(x):
    return x - 1

def add(x, y):
    return x + y

def smap(f):
    return f()

def main():

    f_inc = functools.partial(inc, 4)
    f_dec = functools.partial(dec, 2)
    f_add = functools.partial(add, 3, 4)

    with Pool() as pool:
        res = pool.map(smap, [f_inc, f_dec, f_add])
        print(res)

if __name__ == '__main__':
    main()