求助：C#调用Python进程无法自动终止导致进程数持续增长问题

这问题我之前帮好几个开发者解决过，核心原因就是C#启动的Python进程是独立的，默认不会跟着父进程一起退场。下面给你几个靠谱的解决方案，从简单到进阶都有：

这个是最直接的方法，关键是要保存好启动的Process实例，然后在应用关闭的时候主动关闭它。

WinForms应用示例 #

private Process pythonProcess;

private void StartPythonScript()
{
    var startInfo = new ProcessStartInfo
    {
        FileName = "python.exe",
        Arguments = @"your_script.py",
        UseShellExecute = false,
        CreateNoWindow = true
    };
    pythonProcess = Process.Start(startInfo);
}

private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
{
    if (pythonProcess != null && !pythonProcess.HasExited)
    {
        // 先尝试优雅关闭（适合有退出逻辑的Python脚本），失败再强制终止
        if (!pythonProcess.CloseMainWindow())
        {
            pythonProcess.Kill();
        }
        pythonProcess.WaitForExit(); // 等待进程完全退出
        pythonProcess.Dispose();
    }
}

控制台应用示例 #

private static Process pythonProcess;

static void Main(string[] args)
{
    var startInfo = new ProcessStartInfo
    {
        FileName = "python.exe",
        Arguments = @"your_script.py",
        UseShellExecute = false,
        CreateNoWindow = true
    };
    pythonProcess = Process.Start(startInfo);

    // 注册进程退出事件
    AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit;
    Console.ReadLine();
}

private static void CurrentDomain_ProcessExit(object sender, EventArgs e)
{
    if (pythonProcess != null && !pythonProcess.HasExited)
    {
        if (!pythonProcess.CloseMainWindow())
        {
            pythonProcess.Kill();
        }
        pythonProcess.WaitForExit();
        pythonProcess.Dispose();
    }
}

如果你的C#应用可能意外崩溃（比如未处理的异常），方案1就失效了。这时候可以用Windows Job对象，把Python进程加入Job，只要Job的创建者（C#进程）退出，Job里的所有进程都会被自动终止。

封装Job对象的C#代码 #

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.InteropServices;

public class JobHandle : IDisposable
{
    [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
    private static extern IntPtr CreateJobObject(IntPtr lpJobAttributes, string lpName);

    [DllImport("kernel32.dll")]
    private static extern bool AssignProcessToJobObject(IntPtr hJob, IntPtr hProcess);

    [DllImport("kernel32.dll")]
    private static extern bool SetInformationJobObject(IntPtr hJob, JobObjectInfoType infoType, IntPtr lpJobObjectInfo, uint cbJobObjectInfoLength);

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool CloseHandle(IntPtr hObject);

    private IntPtr _jobHandle;
    private bool _disposed = false;

    public JobHandle()
    {
        _jobHandle = CreateJobObject(IntPtr.Zero, null);
        if (_jobHandle == IntPtr.Zero)
        {
            throw new Win32Exception();
        }

        // 设置Job属性：Job关闭时自动终止所有关联进程
        var info = new JOBOBJECT_EXTENDED_LIMIT_INFORMATION
        {
            BasicLimitInformation = new JOBOBJECT_BASIC_LIMIT_INFORMATION
            {
                LimitFlags = 0x2000 // JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
            }
        };

        int length = Marshal.SizeOf(typeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION));
        IntPtr infoPtr = Marshal.AllocHGlobal(length);
        Marshal.StructureToPtr(info, infoPtr, false);

        if (!SetInformationJobObject(_jobHandle, JobObjectInfoType.ExtendedLimitInformation, infoPtr, (uint)length))
        {
            throw new Win32Exception();
        }

        Marshal.FreeHGlobal(infoPtr);
    }

    public void AssignProcess(Process process)
    {
        if (!AssignProcessToJobObject(_jobHandle, process.Handle))
        {
            throw new Win32Exception();
        }
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return;

        if (_jobHandle != IntPtr.Zero)
        {
            CloseHandle(_jobHandle);
            _jobHandle = IntPtr.Zero;
        }

        _disposed = true;
    }

    ~JobHandle()
    {
        Dispose(false);
    }

    private enum JobObjectInfoType
    {
        ExtendedLimitInformation = 9
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct JOBOBJECT_BASIC_LIMIT_INFORMATION
    {
        public long PerProcessUserTimeLimit;
        public long PerJobUserTimeLimit;
        public uint LimitFlags;
        public UIntPtr MinimumWorkingSetSize;
        public UIntPtr MaximumWorkingSetSize;
        public uint ActiveProcessLimit;
        public UIntPtr Affinity;
        public uint PriorityClass;
        public uint SchedulingClass;
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct IO_COUNTERS
    {
        public ulong ReadOperationCount;
        public ulong WriteOperationCount;
        public ulong OtherOperationCount;
        public ulong ReadTransferCount;
        public ulong WriteTransferCount;
        public ulong OtherTransferCount;
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION
    {
        public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
        public IO_COUNTERS IoInfo;
        public UIntPtr ProcessMemoryLimit;
        public UIntPtr JobMemoryLimit;
        public UIntPtr PeakProcessMemoryUsed;
        public UIntPtr PeakJobMemoryUsed;
    }
}

使用JobHandle启动Python进程 #

private JobHandle jobHandle;
private Process pythonProcess;

private void StartPythonScript()
{
    jobHandle = new JobHandle();

    var startInfo = new ProcessStartInfo
    {
        FileName = "python.exe",
        Arguments = @"your_script.py",
        UseShellExecute = false, // 必须设为false，否则无法将进程加入Job
        CreateNoWindow = true
    };
    pythonProcess = Process.Start(startInfo);
    jobHandle.AssignProcess(pythonProcess);
}

// 应用关闭时可手动释放JobHandle，即使不手动释放，GC回收时也会自动终止进程
private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
{
    jobHandle?.Dispose();
    if (pythonProcess != null && !pythonProcess.HasExited)
    {
        pythonProcess.WaitForExit();
        pythonProcess.Dispose();
    }
}

这个方案的优势是即使C#进程意外崩溃，Job会自动终止所有关联的Python进程，完全避免进程堆积，是最可靠的解决方案。

如果你无法修改C#代码，或者想从Python端做兜底，可以让Python脚本定期检查父进程是否存在，不存在就自动退出。

C#端传递父进程PID #

var startInfo = new ProcessStartInfo
{
    FileName = "python.exe",
    Arguments = $"your_script.py {Process.GetCurrentProcess().Id}",
    UseShellExecute = false,
    CreateNoWindow = true
};
Process.Start(startInfo);

Python脚本实现监听 #

import os
import sys
import time
import psutil

def check_parent_process(parent_pid):
    try:
        parent_process = psutil.Process(parent_pid)
        return parent_process.is_running()
    except psutil.NoSuchProcess:
        return False

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("父进程PID未提供，退出")
        sys.exit(1)
    
    parent_pid = int(sys.argv[1])
    
    # 主业务逻辑循环
    while True:
        # 检查父进程是否存活
        if not check_parent_process(parent_pid):
            print("父进程已退出，Python进程终止")
            sys.exit(0)
        
        # 替换为你的业务代码
        print("Python脚本运行中...")
        time.sleep(5)

这个方案需要安装psutil库（pip install psutil），适合无法修改C#代码的场景，但依赖Python环境的配置。

总结一下，优先推荐方案2，因为它能覆盖正常退出和意外崩溃的所有场景；如果你的应用场景简单，方案1足够用；方案3可以作为兜底补充。

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