背景

目前我主要负责的一个项目是一个 C/S 架构的客户端开发，前端主要是通过 WPF 相关技术来实现，后端是通过 Python 来实现，前后端的数据通信则是通过 MQ 的方式来进行处理。由于 Python 进程是需要依赖客户端进程来运行，为了保证后端业务进程的稳定性，就需要通过一个 守护进程 来守护 Python 进程，防止其由于未知原因而出现进程退出的情况。这里简单记录一下我的一种实现方式。

实现

对于我们的系统而言，我们的 Python 进程只允许存在一个，因此，对应的服务类型要采用单例模式，这一部分代码相对简单，就直接贴出来了，示例代码如下所示：

public partial class PythonService
{
    private static readonly object _locker = new object();

    private static PythonService _instance;
    public static PythonService Current
    {
        get
        {
            if (_instance == null)
            {
                lock (_locker)
                {
                    if (_instance == null)
                    {
                        _instance = new PythonService();
                    }
                }
            }
            return _instance;
        }
    }

    private PythonService()
    {

    }
}

创建独立进程

由于后端的 Python 代码运行需要安装一些第三方的扩展库，所以为了方便，我们采用的方式是总结将 python 安装文件及扩展包和他们的代码一并打包到我们的项目目录中，然后创建一个 Python 进程，在该进程中通过设置环境变量的方式来为 Python 进程进行一些环境配置。示例代码如下所示：

public partial class PythonService
{
    private string _workPath => Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "scripts");
    private string _pythonPath => Path.Combine(_workPath, "python27");

    private bool isRunning = false;
    private int taskPID = -1;

    public void Start()
    {
        taskPID = CreateProcess();
        isRunning = taskPID != -1;

        var msg = isRunning ? "服务启动成功..." : "服务启动失败...";
        Trace.WriteLine(msg);
    }

    public void Stop()
    {
        KillProcessAndChildren(taskPID);

        isRunning = false;
        taskPID = -1;
    }

    private int CreateProcess()
    {
        KillProcessAndChildren(taskPID);

        int pid = -1;
        var psi = new ProcessStartInfo(Path.Combine(_pythonPath, "python.exe"))
        {
            UseShellExecute = false,
            WorkingDirectory = _workPath,
            ErrorDialog = false
        };

        psi.CreateNoWindow = true;

        var path = psi.EnvironmentVariables["PATH"];
        if (path != null)
        {
            var array = path.Split(new[] { ';' }).Where(p => !p.ToLower().Contains("python")).ToList();
            array.AddRange(new[] { _pythonPath, Path.Combine(_pythonPath, "Scripts"), _workPath });
            psi.EnvironmentVariables["PATH"] = string.Join(";", array);
        }
        var ps = new Process { StartInfo = psi };
        if (ps.Start())
        {
            pid = ps.Id;
        }
        return pid;
    }

    private static void KillProcessAndChildren(int pid)
    {
        // Cannot close 'system idle process'.
        if (pid <= 0)
        {
            return;
        }

        ManagementObjectSearcher searcher = new ManagementObjectSearcher("Select * From Win32_Process Where ParentProcessID=" + pid);
        ManagementObjectCollection moc = searcher.Get();
        foreach (ManagementObject mo in moc)
        {
            KillProcessAndChildren(Convert.ToInt32(mo["ProcessID"]));
        }
        try
        {
            Process proc = Process.GetProcessById(pid);
            proc.Kill();
        }
        catch (ArgumentException)
        {
            // Process already exited.
        }
        catch (Win32Exception)
        {
            // Access denied
        }
    }
}

这里有一点需要注意一下，建议使用 PID 来标识我们的 Python 进程，因为如果你使用进程实例或其它方式来对当前运行的进程设置一个引用，当该进程出现一些未知退出，这个时候你通过哪个引用来进行相关操作是会出问题的。

创建守护进程

上面我们的通过记录当前正在运行的进程的 PID 来标识我们的进程，那对应守护进程，我们就可以通过进程列表查询的方式来进行创建，在轮询的过程中，如果未找到对应 PID 的进程则表明该进程已经退出，需要重新创建该进程，否则就不执行任何操作，示例代码如下所示：

public partial class PythonService
{
    private CancellationTokenSource cts;

    private void StartWatch(CancellationToken token)
    {
        Task.Factory.StartNew(() =>
        {
            while (!token.IsCancellationRequested)
            {
                var has = Process.GetProcesses().Any(p => p.Id == taskPID);
                Trace.WriteLine($"MQ状态：{DateTime.Now}-{has}");
                if (!has)
                {
                    taskPID = Cr