python多进程如何分配cpu

Python多进程如何分配CPU：使用multiprocessing模块创建进程、利用Process类创建和管理进程、使用Pool类管理进程池、调整进程的CPU亲和性。

Python的多进程可以通过multiprocessing模块来实现。该模块提供了在多个进程中运行Python代码的能力，从而充分利用多核CPU的优势。使用multiprocessing模块创建进程是最基本的方法，通过Process类创建和启动新进程。利用Process类创建和管理进程，可以更灵活地控制进程的生命周期和行为。使用Pool类管理进程池，可以简化进程管理，适用于需要大量并发任务的场景。最后，调整进程的CPU亲和性可以进一步优化性能，使特定进程绑定到特定CPU核心上。

一、使用`multiprocessing`模块创建进程

Python的multiprocessing模块提供了多进程支持，类似于threading模块。它允许在独立的内存空间中运行多个进程，从而充分利用多核CPU的计算能力。

1、`Process`类

Process类是multiprocessing模块中最基本的类，用于创建和管理独立的进程。每个Process对象表示一个独立的进程。

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

在上述代码中，我们创建了5个进程，每个进程运行worker函数，并传递不同的参数。

2、`Pool`类

Pool类是multiprocessing模块中的一个重要类，用于管理进程池。它允许我们并行地运行多个任务，而不必手动创建和管理每个进程。

from multiprocessing import Pool
def worker(num):
    """线程函数"""
    return f'Worker: {num}'
if __name__ == '__main__':
    with Pool(5) as p:
        print(p.map(worker, range(5)))

在上述代码中，我们使用了Pool类创建了一个包含5个进程的进程池，并通过map方法并行地运行worker函数。

二、利用`Process`类创建和管理进程

使用Process类创建和管理进程具有更大的灵活性和控制力，适用于需要精细控制进程行为的场景。

1、创建进程

创建一个新的Process对象，指定目标函数和参数，然后调用start方法启动进程。

from multiprocessing import Process
def worker(num):
    """线程函数"""
    print(f'Worker: {num}')
if __name__ == '__main__':
    p = Process(target=worker, args=(1,))
    p.start()
    p.join()

2、进程间通信

进程间通信可以通过管道（Pipe）和队列（Queue）实现。管道和队列都提供了在进程间传递数据的机制。

from multiprocessing import Process, Queue
def worker(queue):
    """线程函数"""
    queue.put('Hello from worker')
if __name__ == '__main__':
    queue = Queue()
    p = Process(target=worker, args=(queue,))
    p.start()
    print(queue.get())
    p.join()

在上述代码中，我们使用Queue在主进程和子进程之间传递数据。

三、使用`Pool`类管理进程池

Pool类提供了一种简单的方式来并行地运行多个任务，而不必手动创建和管理每个进程。

1、创建进程池

创建一个包含多个进程的进程池，并通过map方法并行地运行任务。

from multiprocessing import Pool
def worker(num):
    """线程函数"""
    return f'Worker: {num}'
if __name__ == '__main__':
    with Pool(5) as p:
        print(p.map(worker, range(5)))

2、异步执行

Pool类还提供了异步执行任务的功能。通过apply_async方法，可以异步地提交任务，并通过返回的AsyncResult对象获取结果。

from multiprocessing import Pool
def worker(num):
    """线程函数"""
    return f'Worker: {num}'
if __name__ == '__main__':
    with Pool(5) as p:
        result = p.apply_async(worker, (1,))
        print(result.get())

在上述代码中，我们使用apply_async方法异步地提交任务，并通过get方法获取结果。

四、调整进程的CPU亲和性

调整进程的CPU亲和性可以进一步优化性能，使特定进程绑定到特定CPU核心上。这可以通过psutil库实现。

1、安装`psutil`

首先，安装psutil库：

pip install psutil

2、设置CPU亲和性

使用psutil库设置进程的CPU亲和性。

import psutil
from multiprocessing import Process
def worker(num):
    """线程函数"""
    print(f'Worker: {num}')
    p = psutil.Process()
    p.cpu_affinity([num % psutil.cpu_count()])
if __name__ == '__main__':
    processes = []
    for i in range(5):
        p = Process(target=worker, args=(i,))
        processes.append(p)
        p.start()
    for p in processes:
        p.join()

在上述代码中，我们使用psutil库将每个进程绑定到特定的CPU核心上。

五、进程同步和锁机制

在多进程编程中，有时需要确保多个进程之间的同步和资源共享。这可以通过锁机制实现。

1、使用锁

使用multiprocessing模块中的Lock类来实现进程间的同步。

from multiprocessing import Process, Lock
def worker(lock, num):
    """线程函数"""
    with lock:
        print(f'Worker: {num}')
if __name__ == '__main__':
    lock = Lock()
    processes = []
    for i in range(5):
        p = Process(target=worker, args=(lock, i))
        processes.append(p)
        p.start()
    for p in processes:
        p.join()

在上述代码中，我们使用Lock类来确保多个进程之间的同步。

2、使用信号量

信号量（Semaphore）是另一种用于进程间同步的机制。它允许控制对共享资源的访问。

from multiprocessing import Process, Semaphore
def worker(semaphore, num):
    """线程函数"""
    with semaphore:
        print(f'Worker: {num}')
if __name__ == '__main__':
    semaphore = Semaphore(2)
    processes = []
    for i in range(5):
        p = Process(target=worker, args=(semaphore, i))
        processes.append(p)
        p.start()
    for p in processes:
        p.join()

在上述代码中，我们使用Semaphore类来控制对共享资源的访问。

六、进程池的高级用法

进程池不仅可以并行地运行任务，还提供了许多高级功能，如超时控制、回调函数和错误处理。

1、超时控制

使用Pool类的apply_async方法，可以设置任务的超时时间。

from multiprocessing import Pool
import time
def worker(num):
    """线程函数"""
    time.sleep(2)
    return f'Worker: {num}'
if __name__ == '__main__':
    with Pool(5) as p:
        result = p.apply_async(worker, (1,))
        try:
            print(result.get(timeout=1))
        except TimeoutError:
            print("Task timed out")

在上述代码中，我们设置了任务的超时时间，并捕获超时异常。

2、回调函数

apply_async方法还支持回调函数。回调函数将在任务完成后被调用。

from multiprocessing import Pool
def worker(num):
    """线程函数"""
    return f'Worker: {num}'
def callback(result):
    """回调函数"""
    print(f'Callback: {result}')
if __name__ == '__main__':
    with Pool(5) as p:
        p.apply_async(worker, (1,), callback=callback)
        p.close()
        p.join()

在上述代码中，我们定义了一个回调函数，并在任务完成后调用该回调函数。

3、错误处理

apply_async方法还支持错误处理。可以通过回调函数捕获和处理异常。

from multiprocessing import Pool
def worker(num):
    """线程函数"""
    if num == 2:
        raise ValueError("An error occurred")
    return f'Worker: {num}'
def error_callback(exception):
    """错误回调函数"""
    print(f'Error: {exception}')
if __name__ == '__main__':
    with Pool(5) as p:
        for i in range(5):
            p.apply_async(worker, (i,), error_callback=error_callback)
        p.close()
        p.join()

在上述代码中，我们定义了一个错误回调函数，并在任务发生异常时调用该回调函数。

七、项目管理系统推荐

在进行多进程编程时，使用合适的项目管理系统可以提高开发效率和协作效果。以下是两个推荐的项目管理系统：

1、研发项目管理系统PingCode

PingCode是一款专为研发团队设计的项目管理系统，提供了全面的需求管理、任务管理、缺陷管理和版本管理功能。它支持敏捷开发、Scrum和Kanban等多种研发模式，帮助团队更好地管理项目进度和质量。

2、通用项目管理软件Worktile

Worktile是一款通用的项目管理软件，适用于各类团队和项目。它提供了任务管理、文档管理、时间管理和团队协作等功能，支持甘特图、看板和日历视图，帮助团队更高效地完成项目。

总结：通过使用Python的multiprocessing模块，可以创建和管理多个进程，充分利用多核CPU的计算能力。利用Process类和Pool类，可以灵活地控制进程的行为和管理进程池。调整进程的CPU亲和性和使用进程同步机制，可以进一步优化性能和确保进程间的资源共享。同时，使用合适的项目管理系统，如PingCode和Worktile，可以提高开发效率和协作效果。