你的需求非常典型——既要利用多进程提速，又要让每个进程的输出（包括动态进度条）清晰隔离，避免手动分屏的繁琐。下面是几个比当前libtmux临时方案更可靠的解决思路：

方案1：修复并优化libtmux + FIFO方案 #

你当前遇到的attach_session()导致窗格为空的问题，核心是FIFO的阻塞特性与进程启动时机不匹配。下面是修正后的代码，解决了这个问题同时优化了整体实现：

import os
import sys
import tempfile
import time
import threading
from multiprocessing import Pool, current_process
import libtmux
from tqdm import tqdm

def setup(para, fifo_paths):
    pid_suffix = int(current_process().name.split("-")[-1])
    # 按进程ID动态分配FIFO，支持任意数量的并行进程
    fifo_idx = pid_suffix % len(fifo_paths)
    fifo_write = open(fifo_paths[fifo_idx], "w", buffering=1)
    sys.stdout = fifo_write
    sys.stderr = fifo_write
    run(para, pid_suffix)
    fifo_write.close()

def run(para, pid):
    print(f"start run nr. {para} on process {pid}")
    for _ in tqdm(range(10), desc=f"Task {para}"):
        time.sleep(0.5)
    print(f"finished run nr. {para}")

def attach_tmux_session(session):
    # 延迟attach，确保进程已开始写入FIFO，避免窗格为空
    time.sleep(1)
    os.system(f"tmux attach-session -t {session.session_name}")

if __name__ == "__main__":
    parameter_space = [1,2,3,4,5,6]
    parallel_workers = 3  # 可根据CPU核心数调整
    session_name = "parallel_task_session"
    
    # 自动清理临时目录，避免残留文件
    with tempfile.TemporaryDirectory() as tmpdir:
        fifo_paths = [os.path.join(tmpdir, f"fifo{i}") for i in range(parallel_workers)]
        for fifo in fifo_paths:
            os.mkfifo(fifo)
        
        # 初始化tmux会话，先清理已存在的同名会话
        server = libtmux.Server()
        existing_session = server.find_where({"session_name": session_name})
        if existing_session:
            existing_session.kill_session()
        
        # 用tail -f替代cat，解决FIFO阻塞导致的无输出问题
        session = server.new_session(
            session_name=session_name,
            window_command=f"tail -f {fifo_paths[0]}"
        )
        window = session.windows[0]
        
        # 分割出对应并行数的窗格
        for fifo in fifo_paths[1:]:
            window.split_window(shell=f"tail -f {fifo}")
        
        # 用线程处理attach，避免阻塞主进程启动多任务
        threading.Thread(target=attach_tmux_session, args=(session,), daemon=True).start()
        
        # 启动多进程池执行任务
        with Pool(parallel_workers) as p:
            p.starmap(setup, [(para, fifo_paths) for para in parameter_space])
        
        # 任务完成后自动销毁会话
        session.kill_session()

核心优化点： #

• 用tail -f替代cat，彻底解决FIFO阻塞导致的窗格无输出问题
• 动态创建对应并行数的FIFO，支持任意数量的并行进程
• 用线程延迟attach，确保进程已开始写入输出再连接会话
• 使用TemporaryDirectory自动清理临时文件，避免系统残留

方案2：用tmuxp实现配置化分屏 #

tmuxp是libtmux的上层封装，支持用YAML配置文件定义会话布局，比手动写代码分割窗格更易维护：

1. 安装tmuxp：pip install tmuxp
2. 创建配置文件parallel_tasks.yaml：

session_name: parallel_tasks
windows:
- window_name: task_monitor
  panes:
  - shell_command: "tail -f ./task1.log"
  - shell_command: "tail -f ./task2.log"
  - shell_command: "tail -f ./task3.log"

3. 修改Python代码，将每个进程的输出写入对应日志文件：

import os
import sys
import time
from multiprocessing import Pool, current_process
from tqdm import tqdm

def run_task(para):
    pid_suffix = int(current_process().name.split("-")[-1])
    log_path = f"./task{pid_suffix % 3 +1}.log"
    # 清空旧日志文件
    open(log_path, "w").close()
    # 重定向输出到日志文件
    with open(log_path, "a", buffering=1) as f:
        sys.stdout = f
        sys.stderr = f
        print(f"start run nr. {para} on process {pid_suffix}")
        for _ in tqdm(range(10), desc=f"Task {para}"):
            time.sleep(0.5)
        print(f"finished run nr. {para}")

if __name__ == "__main__":
    # 启动tmuxp会话（后台运行）
    os.system("tmuxp load parallel_tasks.yaml &")
    time.sleep(1)
    
    parameter_space = [1,2,3,4,5,6]
    with Pool(3) as p:
        p.map(run_task, parameter_space)
    
    # 任务完成后自动关闭会话（可选）
    os.system("tmux kill-session -t parallel_tasks")
    # 清理日志文件（可选）
    for i in range(1,4):
        os.remove(f"./task{i}.log")

优点： #

• 布局配置可视化，无需手动写代码分割窗格
• 日志文件可保留，方便后续排查问题
• 会话管理更稳定，避免libtmux的底层API问题

方案3：纯Python实现分屏输出（无需tmux） #

如果不想依赖终端复用工具，可以用rich库实现终端内的多区域输出，完全用Python控制，跨平台兼容：

1. 安装rich：pip install rich
2. 代码示例：

import time
from multiprocessing import Pool, Queue
from tqdm import tqdm
from rich.live import Live
from rich.panel import Panel
from rich.columns import Columns

# 用队列传递每个进程的输出，实现进程间通信
output_queue = Queue()

def run_task(para):
    task_id = para
    output_queue.put((task_id, f"[green]start run nr. {task_id}[/green]"))
    for i in tqdm(range(10), desc=f"Task {task_id}"):
        time.sleep(0.5)
        # 将进度条状态传递到队列
        output_queue.put((task_id, f"Progress: {i+1}/10"))
    output_queue.put((task_id, f"[blue]finished run nr. {task_id}[/blue]"))

def update_display():
    # 收集所有任务的最新输出
    task_outputs = {}
    while not output_queue.empty():
        task_id, msg = output_queue.get()
        task_outputs[task_id] = msg
    # 生成分屏面板，每个任务一个独立区域
    panels = [Panel(f"Task {tid}\n{msg}", title=f"Task {tid}") for tid, msg in task_outputs.items()]
    return Columns(panels)

if __name__ == "__main__":
    parameter_space = [1,2,3,4,5,6]
    with Pool(3) as p:
        # 异步启动任务，避免阻塞显示线程
        p.map_async(run_task, parameter_space)
        
        # 启动rich的实时显示，动态更新分屏内容
        with Live(update_display(), refresh_per_second=2) as live:
            # 等待所有任务完成
            while not p._pool._join_exited_ok():
                live.update(update_display())
                time.sleep(0.1)

优点： #

• 无需依赖tmux/screen，纯Python实现，跨平台兼容（Windows也能运行）
• 动态更新的分屏布局，支持tqdm进度条的状态展示
• 可以自定义面板样式，输出更美观

总结 #

• 如果习惯用tmux，方案1或2是最优选择，能完美隔离每个进程的输出（包括tqdm的动态进度条）
• 如果需要跨平台或不想依赖终端复用工具，方案3的rich实现更灵活

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