如何用Python多进程无需等待地在不同处理器运行可执行文件？

我想要同时在不同处理器上运行不同的可执行文件，参考了示例尝试运行可执行文件，但发现循环会等待当前可执行文件完成后才分配新进程。请问是否有无需等待即可为下一个核心分配新进程的方法？

现有代码 #

import os
from itertools import cycle
import multiprocessing as mp
import subprocess

def map_hack(AFF):
  my_pid = os.getpid()
  old_aff = os.sched_getaffinity(0)
  os.sched_setaffinity(0,AFF)
  return (my_pid, old_aff, os.sched_getaffinity(0))

PROCESSES = os.cpu_count()
_mycpus = cycle(os.sched_getaffinity(0))
cpus = [[next(_mycpus)] for x in range(PROCESSES)]

with mp.Pool(processes=PROCESSES) as pool:
  for x in pool.map(map_hack, cpus, chunksize=1):
     print("Try 2:My pid is {} and my old aff was {}, my new aff is {}".format(*x))
    z = str( x[2])
    z = z[:-1]
    z = int( z[-1:])
    print (z)
    if (z == 0):
        print("program waits for this executable to finish")
        subprocess.run(["./exevision"])

pool.close()
pool.join()

你的代码存在两个核心问题导致无法并行启动可执行文件：

1. pool.map会等待所有map_hack子进程完成任务后才返回结果列表，主进程的循环只能串行处理这些结果
2. 主进程中调用subprocess.run是阻塞式的，必须等待当前可执行文件运行完毕才会继续执行循环

要实现无需等待即可为每个核心分配并启动进程，只需把启动可执行文件的逻辑移到子进程内部，使用非阻塞的subprocess.Popen替代subprocess.run：

修改后的代码 #

import os
import multiprocessing as mp
import subprocess

def run_on_cpu(cpu_core):
    # 设置当前进程的CPU亲和性
    os.sched_setaffinity(0, [cpu_core])
    pid = os.getpid()
    print(f"进程 {pid} 绑定到核心 {cpu_core}")
    
    # 根据核心号选择对应的可执行文件（这里示例用核心号区分，你可以按需修改映射关系）
    executable = "./exevision" if cpu_core == 0 else f"./exevision_{cpu_core}"
    
    # 非阻塞启动可执行文件
    process = subprocess.Popen([executable])
    # 如果不需要等待外部程序完成，可直接删除下面这行
    process.wait()
    
    return f"进程 {pid} 完成任务"

if __name__ == "__main__":
    PROCESSES = os.cpu_count()
    # 获取所有可用CPU核心
    cpu_cores = list(os.sched_getaffinity(0))
    
    with mp.Pool(processes=PROCESSES) as pool:
        # 并行提交任务，每个核心对应一个子进程
        results = pool.map(run_on_cpu, cpu_cores)
        
    for res in results:
        print(res)

关键改动说明 #

• 将启动可执行文件的逻辑移到run_on_cpu子进程函数中，每个子进程绑定指定核心后直接启动对应可执行文件，实现真正的并行分配
• 使用subprocess.Popen替代subprocess.run：Popen会立即返回，不会阻塞子进程执行，确保多个可执行文件能同时启动
• 简化核心分配逻辑，直接使用可用核心列表，避免不必要的循环迭代
• 新增核心号与可执行文件的映射逻辑，你可以根据实际需求调整（比如用字典定义每个核心对应的可执行文件路径）

如果不需要等待外部可执行文件运行完毕，直接删除process.wait()即可，子进程启动外部程序后会立即退出，而外部程序会继续在绑定的核心上运行。

内容的提问来源于stack exchange，提问作者nadirkazan