python 标准库的 `multiprocessing.pool` 按进程数而非核心数配置，并不直接支持“每个工作进程独占 n 个核心”的语义；但可通过合理计算进程数量、结合系统级绑核（如 `psutil` 或 `taskset`）实现等效效果。

在 Python 多进程编程中，multiprocessing.Pool 的构造参数 processes 表示启动多少个独立进程，而非“为每个进程分配多少逻辑核心”。操作系统内核负责将这些进程调度到可用 CPU 上，因此默认情况下，多个进程可能竞争同一组核心，无法保证资源隔离或并行带宽。

若你希望每个工作进程稳定占用 N_CORES_PER_PROCESS 个逻辑核心（例如运行 OpenMP 或 NumPy 多线程计算），关键在于两点：

1. 控制并发进程数：确保总核心数 ≥ 进程数 × 每进程所需核心数；
2. 显式绑定进程到指定 CPU 集合（CPU affinity），避免跨核迁移与争抢。

✅ 正确做法示例（10 核总资源，每进程固定占 2 核）：

import multiprocessing as mp
import os
import psutil  # pip install psutil

def bind_to_cores(cores):
    """将当前进程绑定到指定 CPU 核心列表"""
    p = psutil.Process()
    p.cpu_affinity(cores)

def worker_init(assigned_cores):
    """Pool 初始化函数：为每
个 worker 绑定专属核心"""
    bind_to_cores(assigned_cores)

def func(x):
    return x ** 2

if __name__ == "__main__":
    TOTAL_CORES = 10
    N_CORES_PER_PROCESS = 2
    RESERVED_CORES = 2  # 为主进程保留 2 核（可选）

    # 计算最大安全工作进程数
    available_cores = TOTAL_CORES - RESERVED_CORES
    n_workers = max(1, available_cores // N_CORES_PER_PROCESS)  # e.g., (10-2)//2 = 4

    # 划分核心：为每个 worker 分配互斥的 core slice
    core_slices = [
        list(range(i * N_CORES_PER_PROCESS, (i + 1) * N_CORES_PER_PROCESS))
        for i in range(n_workers)
    ]

    # 创建 Pool，传入对应核心集合作为初始化参数
    with mp.Pool(
        processes=n_workers,
        initializer=worker_init,
        initargs=(core_slices[0],)  # 注意：此处需动态适配，实际推荐用 concurrent.futures + ProcessPoolExecutor + 自定义启动
    ) as pool:
        # ⚠️ 标准 Pool 不支持 per-worker initargs 变量传递，更稳健方案见下方
        results = pool.map(func, range(10000))

⚠️ 注意：multiprocessing.Pool 的 initargs 对所有 worker 是静态统一的，无法为每个 worker 指定不同核心集。因此，生产环境推荐使用 concurrent.futures.ProcessPoolExecutor 配合自定义进程类，或借助第三方库如 loky（支持更灵活的资源感知调度）。

? 更健壮的替代方案（推荐）：

from concurrent.futures import ProcessPoolExecutor
import psutil

def bound_worker(task_args, cpu_ids):
    bind_to_cores(cpu_ids)  # 先绑核
    x, = task_args
    return x ** 2

if __name__ == "__main__":
    TOTAL_CORES = 10
    N_PER = 2
    n_workers = (TOTAL_CORES - 2) // N_PER

    core_groups = [list(range(i*N_PER, (i+1)*N_PER)) for i in range(n_workers)]
    tasks = [(i,) for i in range(10000)]

    with ProcessPoolExecutor(max_workers=n_workers) as executor:
        # 手动分发任务 + 核心组
        futures = [
            executor.submit(bound_worker, task, core_groups[i % n_workers])
            for i, task in enumerate(tasks)
        ]
        results = [f.result() for f in futures]

? 总结：

• Python 无原生 cool_new_pool，因核心是 OS 调度资源，非 Python 运行时硬约束；
• 真正的“N 核/进程”需靠 进程数控制 + CPU 亲和性绑定 协同实现；
• 优先使用 psutil.Process().cpu_affinity() 实现绑核，避免 os.sched_setaffinity 的平台限制；
• 对计算密集型混合多线程任务（如调用 BLAS/OpenMP），务必关闭其内部线程池（如设置 OMP_NUM_THREADS=1, OPENBLAS_NUM_THREADS=1），否则会破坏核心配额。