python 如何控制进程数

Python 控制进程数的方法包括使用 multiprocessing 库、concurrent.futures 模块和第三方库 like Celery。 其中，使用 multiprocessing 库是最常见且简单的方法，通过创建进程池（Pool）来控制进程数。接下来，我们将详细介绍这几种方法，并逐步展开讲解如何在实际应用中使用它们来控制进程数。

一、使用 multiprocessing 库

multiprocessing 是 Python 标准库的一部分，它支持以进程为基础的并行编程。通过创建进程池（Pool），可以方便地控制并发进程的数量。

1、创建进程池

使用 multiprocessing.Pool 可以轻松创建一个进程池，并通过参数控制进程数量。以下是一个简单的示例：

from multiprocessing import Pool
def worker(num):
    print(f"Worker: {num}")
if __name__ == "__main__":
    pool = Pool(processes=4)  # 设定进程池的进程数量为 4
    pool.map(worker, range(10))
    pool.close()
    pool.join()

在这个示例中，我们创建了一个包含 4 个进程的进程池，并使用 map 方法将任务分配给这些进程。

2、使用 apply 和 apply_async

除了 map 方法，multiprocessing 库还提供了 apply 和 apply_async 方法来控制进程数：

from multiprocessing import Pool
import time
def worker(num):
    time.sleep(1)
    return num * 2
if __name__ == "__main__":
    pool = Pool(processes=4)
    results = [pool.apply_async(worker, (i,)) for i in range(10)]
    output = [p.get() for p in results]
    print(output)
    pool.close()
    pool.join()

apply_async 是异步执行的，它返回的是一个 ApplyResult 对象，通过调用 get 方法可以获取执行结果。

二、使用 concurrent.futures 模块

concurrent.futures 模块提供了一个高级接口，用于异步执行调用。它支持线程和进程池，使用起来也非常方便。

1、使用 ProcessPoolExecutor

concurrent.futures.ProcessPoolExecutor 提供了类似于 multiprocessing.Pool 的功能：

from concurrent.futures import ProcessPoolExecutor
def worker(num):
    return num * 2
if __name__ == "__main__":
    with ProcessPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(worker, range(10)))
    print(results)

在这个示例中，我们使用 ProcessPoolExecutor 创建了一个包含 4 个进程的进程池，并通过 map 方法执行任务。

2、使用 submit 和 as_completed

除了 map 方法，concurrent.futures 还提供了 submit 和 as_completed 方法：

from concurrent.futures import ProcessPoolExecutor, as_completed
def worker(num):
    return num * 2
if __name__ == "__main__":
    with ProcessPoolExecutor(max_workers=4) as executor:
        futures = [executor.submit(worker, i) for i in range(10)]
        for future in as_completed(futures):
            print(future.result())

submit 方法可以提交单个任务，返回一个 Future 对象，通过 as_completed 可以获得任务执行结果。

三、使用第三方库 Celery

Celery 是一个分布式任务队列系统，可以非常方便地实现任务的并行执行和进程控制。

1、安装 Celery

首先需要安装 Celery：

pip install celery

2、配置 Celery

创建一个 Celery 应用并配置：

from celery import Celery
app = Celery('tasks', broker='pyamqp://guest@localhost//')
@app.task
def worker(num):
    return num * 2

在这个示例中，我们创建了一个 Celery 应用，并定义了一个任务 worker。

3、启动 Celery Worker

在命令行中启动 Celery Worker：

celery -A tasks worker --loglevel=info --concurrency=4

--concurrency 参数用来控制并发的任务数量。

4、调用任务

在 Python 脚本中调用任务：

from tasks import worker
if __name__ == "__main__":
    results = [worker.delay(i) for i in range(10)]
    for result in results:
        print(result.get())

通过 delay 方法可以异步调用任务，通过 get 方法可以获取任务执行结果。

四、其他方法

除了上述方法，还有一些其他控制进程数的方法，例如：

1、手动创建进程

可以使用 multiprocessing.Process 手动创建和管理进程：

from multiprocessing import Process
def worker(num):
    print(f"Worker: {num}")
if __name__ == "__main__":
    processes = []
    for i in range(10):
        p = Process(target=worker, args=(i,))
        processes.append(p)
        p.start()
    for p in processes:
        p.join()

这种方法比较灵活，但需要手动管理进程的创建和销毁。

2、使用 joblib 库

joblib 库提供了一些简便的方法来进行并行计算：

from joblib import Parallel, delayed
def worker(num):
    return num * 2
if __name__ == "__main__":
    results = Parallel(n_jobs=4)(delayed(worker)(i) for i in range(10))
    print(results)

joblib 库的 Parallel 和 delayed 方法可以非常方便地进行并行计算和控制进程数。

总之，Python 提供了多种方法来控制进程数，包括标准库中的 multiprocessing 和 concurrent.futures 模块，以及第三方库如 Celery 和 joblib。根据具体的应用场景和需求，可以选择合适的方法来进行并行计算和控制进程数。