python 异常、捕获和退出,进程调用输出示例解析

# problematic_subprocess.py
import sys
import os
import time
def func():
    for i in range(3):
        print(f"Iteration {i}")
        # 正常输出
        print("This is a normal stdout message.")
        print("Another stdout message.", file=sys.stdout)
        time.sleep(1)
        # 错误输出
        print("This is a stderr message.", file=sys.stderr)
        print("Another stderr message.", file=sys.stderr)
    return 0
if __name__ == "__main__":
    ret = 0 # 作为后面预留使用
    try:
        ret = func()
        print(f"{__file__}: Return code: {ret}")
    except Exception as e:
        print(f"{__file__}: Exception: {e}")
        ret = -1
    finally:
        print(f"{__file__}: Finally block executed.")
        print(f"{__file__}: Exiting with return code: {ret}")

    # return 0
    raise Exception("An exception occurred.")

c:\Users\admin\Desktop\process_popen\problematic_subprocess.py: Exception: An exception occurred.
c:\Users\admin\Desktop\process_popen\problematic_subprocess.py: Finally block executed.
c:\Users\admin\Desktop\process_popen\problematic_subprocess.py: Exiting with return code: -1

import subprocess
if __name__ == "__main__":
    process = subprocess.Popen(["python", "problematic_subprocess.py"])
    ret_code = process.wait()
    print("Return code: {}".format(ret_code))

# problematic_subprocess.py
print("hello world!")

hello world!
Return code: 0

    # return 0
    # raise Exception("An exception occurred.")
    sys.exit(2)

C:\Users\admin\Desktop\process_popen\problematic_subprocess.py: Finally block executed.
C:\Users\admin\Desktop\process_popen\problematic_subprocess.py: Exiting with return code: 0
Return code: 2

    # return 0
    # raise Exception("An exception occurred.")
    # sys.exit(2)
    os._exit(3)

Return code: 3

    # return 0
    # raise Exception("An exception occurred.")
    # sys.exit(2)
    # os._exit(3)
    os.abort() 

Return code: 3221226505

import subprocess
import threading
import logging
def setup_loggers(stdout_log_file="stdout.log", stderr_log_file="stderr.log"):
    """
    为 stdout 和 stderr 创建独立的日志记录器
    """
    # 配置日志格式
    log_format = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    )
    # 设置 stdout 日志记录器
    stdout_logger = logging.getLogger("STDOUT")
    stdout_logger.setLevel(logging.INFO)
    stdout_handler = logging.FileHandler(stdout_log_file, mode='w', encoding='utf-8')
    stdout_handler.setFormatter(log_format)
    stdout_logger.addHandler(stdout_handler)
    # 设置 stderr 日志记录器
    stderr_logger = logging.getLogger("STDERR")
    stderr_logger.setLevel(logging.ERROR)
    stderr_handler = logging.FileHandler(stderr_log_file, mode='w', encoding='utf-8')
    stderr_handler.setFormatter(log_format)
    stderr_logger.addHandler(stderr_handler)
    # 防止日志传播到根记录器
    stdout_logger.propagate = False
    stderr_logger.propagate = False
    return stdout_logger, stderr_logger
def write_stream_to_logger(stream, logger, level=logging.INFO):
    """将流中的数据实时写入日志记录器"""
    print(f"write_stream_to_logger: {logger.name}")
    for line in stream:
        # 去除行尾的换行符
        log_message = line.rstrip('\n\r')
        logger.log(level, log_message)
def run_process_and_log_output(command, stdout_file="stdout.txt", stderr_file="stderr.txt"):
    """
    使用 Popen 执行命令，并实时将标准输出和标准错误写入指定文件，
    无论进程是否正常结束。
    """
    # 设置日志记录器
    stdout_logger, stderr_logger = setup_loggers(stdout_file, stderr_file)
    try:
        print(f"Starting process: {command}")
        # 启动子进程
        process = subprocess.Popen(
            command,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True,
            # bufsize=1,
            universal_newlines=True,
            shell=isinstance(command, str)
        )
        # 输出进程相关信息
        print(f"Process started with PID: {process.pid}")
        # 创建线程来处理 stdout 和 stderr
        stdout_thread = threading.Thread(
            target=write_stream_to_logger, 
            args=(process.stdout, stdout_logger, logging.INFO)
        )
        stderr_thread = threading.Thread(
            target=write_stream_to_logger, 
            args=(process.stderr, stderr_logger, logging.ERROR)
        )
        # 启动线程
        stdout_thread.start()
        stderr_thread.start()
        # 等待进程结束
        return_code = process.wait()
        # 等待线程完成
        stdout_thread.join()
        stderr_thread.join()
        print(f"Process finished with return code: {return_code}")
        return return_code
    except Exception as e:
        print(f"An error occurred: {e}")
        with open(stdout_file, 'w', encoding='utf-8') as f:
            f.write("")
        with open(stderr_file, 'w', encoding='utf-8') as f:
            f.write(f"An error occurred: {e}")
        return -2
        # raise
    finally:
        # 确保文件被关闭
        if process.stdout:
            process.stdout.close()
        if process.stderr:
            process.stderr.close()
# 示例用法
if __name__ == "__main__":
    problematic_cmd = ["python", "problematic_subprocess.py"]
    print("Running problematic subprocess...")
    ret_code = run_process_and_log_output(problematic_cmd, "stdout.txt", "stderr.txt")
    print(f"Problematic subprocess finished with return code: {ret_code}")		
    ```
以上代码中，不论前述problematic_subprocess.py是如何执行，return_code = process.wait() 都会成功，接收到进程的返回值。
例如在 func 中 抛出异常， 进程不显式指定返回指，那么进程默认返回值为0。 实际输出也符合预期
```py
Running problematic subprocess...
Starting process: ['python', 'problematic_subprocess.py']
Process started with PID: 24808
write_stream_to_logger: STDOUT
write_stream_to_logger: STDERR
Process finished with return code: 0
Problematic subprocess finished with return code: 0

        # 等待1s，通知退出
        time.sleep(1)
        import psutil
        master_process = psutil.Process(process.pid)
        if master_process.is_running():
            print("Process is still running, sending SIGTERM...")
            master_process.terminate()
            time.sleep(1)
            if master_process.is_running():
                print("Process is still running, sending SIGKILL...")
                master_process.kill()
                time.sleep(1)
                if master_process.is_running():
                    print("Process is still running, giving up...")
                    return -1