如何在Python子进程完成前读取输出并解决阻塞问题

方法1：使用select模块监听文件描述符 #

利用select.select()监听stdout的可读状态，搭配超时设置避免readline()无限阻塞。示例代码：

import subprocess
import select
import time

timeout = 30  # 自定义超时阈值
with subprocess.Popen("<my command>", stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1) as proc:
    while time.time() < timeout:
        # 监听stdout，设置0.5秒超时
        ready, _, _ = select.select([proc.stdout], [], [], 0.5)
        if ready:
            line = proc.stdout.readline()
            if not line:  # 子进程输出流已关闭
                break
            # 处理输出逻辑
            print(f"进度输出: {line.strip()}")
        
        # 检查子进程是否已终止
        if proc.poll() is not None:
            # 读取剩余输出
            for remaining_line in proc.stdout:
                print(f"剩余输出: {remaining_line.strip()}")
            break
    else:
        # 超时处理：终止子进程
        proc.terminate()
        proc.wait()
        print("子进程执行超时")

核心逻辑是通过select判断stdout是否有数据可读，再调用readline()，彻底避免无数据时的阻塞。

方法2：用线程分离IO读取操作 #

把stdout和stderr的读取放到独立线程中，主进程专注监控超时和子进程状态，不会被IO操作阻塞。示例代码：

import subprocess
import threading
import time

def read_stream(stream, handler):
    for line in iter(stream.readline, ''):
        handler(line.strip())
    stream.close()

timeout = 30
with subprocess.Popen("<my command>", stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1) as proc:
    # 定义输出处理函数
    def handle_stdout(line):
        print(f"进度输出: {line}")
    
    def handle_stderr(line):
        print(f"错误信息: {line}")
    
    # 启动线程分别处理stdout和stderr
    stdout_thread = threading.Thread(target=read_stream, args=(proc.stdout, handle_stdout))
    stderr_thread = threading.Thread(target=read_stream, args=(proc.stderr, handle_stderr))
    stdout_thread.start()
    stderr_thread.start()
    
    # 主进程监控超时与子进程状态
    start_time = time.time()
    while proc.poll() is None:
        if time.time() - start_time > timeout:
            proc.terminate()
            print("子进程超时终止")
            break
        time.sleep(0.1)
    
    # 等待线程完成收尾
    stdout_thread.join()
    stderr_thread.join()

线程会持续读取输出直到流关闭，主进程无需等待IO操作，全程可控。

方法3：设置非阻塞模式（平台依赖） #

通过系统调用将stdout设置为非阻塞模式，这样readline()在无数据时会抛出异常，捕获后即可继续执行循环。示例（Linux/macOS）：

import subprocess
import time
import fcntl
import os

timeout = 30
with subprocess.Popen("<my command>", stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1) as proc:
    # 将stdout设为非阻塞模式
    fd = proc.stdout.fileno()
    fl = fcntl.fcntl(fd, fcntl.F_GETFL)
    fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
    
    start_time = time.time()
    while time.time() < start_time + timeout:
        try:
            line = proc.stdout.readline()
            if line:
                print(f"进度输出: {line.strip()}")
            elif proc.poll() is not None:
                # 子进程终止，读取剩余输出
                remaining = proc.stdout.read()
                if remaining:
                    print(f"剩余输出: {remaining.strip()}")
                break
        except IOError:
            # 无数据可读时的异常，直接跳过
            pass
        time.sleep(0.1)
    else:
        proc.terminate()
        proc.wait()
        print("子进程执行超时")

注意：Windows平台需使用msvcrt.setmode实现非阻塞，跨平台场景需增加兼容性判断。

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