如何在批处理文件中实现多线程或并行进程以执行仿真任务？

方案1：临时标记文件法（无额外依赖，原生实现） #

实现逻辑：

• 每个仿真任务执行完成后生成一个唯一的空标记文件
• 主进程启动所有仿真任务后，轮询标记文件数量，匹配总任务数后再执行后处理

完整代码示例： #

@echo off
setlocal enabledelayedexpansion
:: 先清空旧的标记文件
del /q task_*.done 2>nul

:: 配置总参数
set "total_task=0"
:: 你原来的嵌套循环，启动并行任务
for %%f in (1 2 3) do (
    for %%a in (4 5 6) do (
        for %%b in (7 8 9) do (
            set /a total_task+=1
            :: 启动绑核的仿真任务，可根据需求加affinity参数绑核
            start "仿真任务!total_task!" /min cmd /c "call :mission %%f %%a %%b !total_task!"
        )
    )
)

:: 等待所有任务完成
:wait_loop
:: 统计当前已完成的任务数
set "finished=0"
for %%x in (task_*.done) do set /a finished+=1
if not !finished! equ !total_task! (
    :: 间隔2秒再检查，避免占用太多CPU
    timeout /t 2 /nobreak >nul
    goto wait_loop
)

:: 所有任务完成，执行后处理
echo 所有仿真已完成，开始后处理...
some gawk scripts
some python scripts
some r scripts

:: 清理临时标记文件
del /q task_*.done 2>nul
goto :exit

:mission
:: 你原来的mission逻辑
sed -e 's/text1/%1/' -e 's/text2/%2/' -e 's/text3/%3/'
simulation.exe
:: 任务完成，生成标记文件
echo. > task_%4.done
goto :eof

:exit
endlocal

方案2：按核心分批跑的优化方案（适合1000+大任务量场景） #

如果任务量过大，直接启动上千个后台进程会导致系统资源占用过高，你可以按CPU核心数拆分任务队列，每个核心绑定一个进程，进程内串行跑分配给自己的任务：

@echo off
setlocal enabledelayedexpansion
del /q core_*.done 2>nul

:: 配置核心数，比如4核
set core_num=4
:: 先把所有任务参数存到列表里
set "task_list="
set total_task=0
for %%f in (1 2 3) do (
    for %%a in (4 5 6) do (
        for %%b in (7 8 9) do (
            set /a total_task+=1
            set task_list=!task_list! "%%f,%%a,%%b"
        )
    )
)

:: 计算每个核心分配的任务数
set /a per_core_task=total_task / core_num
:: 启动每个核心的处理进程
for /l %%c in (1,1,%core_num%) do (
    set /a start_idx=(%%c-1)*per_core_task + 1
    set /a end_idx=%%c*per_core_task
    :: 最后一个核心处理剩下的所有任务
    if %%c equ %core_num% set end_idx=%total_task%
    :: 绑定核心启动任务进程
    start "核心%%c任务" /affinity %%c cmd /c "call :core_mission %%c !start_idx! !end_idx!"
)

:: 等待所有核心进程完成
:wait_core
set finished_core=0
for %%x in (core_*.done) do set /a finished_core+=1
if not !finished_core! equ %core_num% (
    timeout /t 5 /nobreak >nul
    goto wait_core
)

:: 执行后处理
echo 所有核心任务完成，开始后处理
some gawk scripts
some python scripts
some r scripts

del /q core_*.done 2>nul
goto :exit

:core_mission
set core_id=%1
set start=%2
set end=%3
:: 遍历任务列表，跑自己分配到的任务
set idx=0
for %%t in (%task_list%) do (
    set /a idx+=1
    if !idx! geq %start% if !idx! leq %end% (
        for /f "tokens=1-3 delims=," %%f in (%%t) do (
            sed -e 's/text1/%%f/' -e 's/text2/%%g/' -e 's/text3/%%h/'
            simulation.exe
        )
    )
)
:: 核心任务完成，生成标记
echo. > core_%core_id%.done
goto :eof

:exit
endlocal

注意事项 #

• start /affinity的参数是16进制掩码，比如绑核心1是1，核心2是2，核心3是4，核心4是8，如果是多核心绑定的话需要计算对应掩码，单核心绑定按1、2、4、8顺序写兼容性最好
• 任务量很大的情况下优先用方案2，避免进程过多导致系统卡顿
• 轮询等待的间隔可以自己调整，任务运行时间长的话可以设成10秒甚至更长，减少资源占用

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