即使 Killed 和 Disposed（在 Linux 上），C# 启动进程也会泄漏内存

Question

注意：根据测试（参见下面的编辑），这只发生在 Linux 机器上。

我有一个在 Raspberry Pi 上运行的 ASP.NET Core Blazor 应用程序（使用服务器端托管模型）。应用程序的部分功能是根据上次与系统交互的时间来调暗/调亮屏幕。为此，我每隔 1 秒左右生成一个终端子进程来运行 xprintidle，解析其输出并采取相应措施。

我使用 DataDog 进行监控，我一直有内存泄漏，直到系统崩溃（需要几天时间才能用完所有内存，但最终确实会发生）：

我已经指出以下方法是内存泄漏的原因 - 如果我跳过调用它并使用一些恒定的时间跨度，内存不会泄漏： 我有以下代码：

// note this code has some parts that aren't even needed - I was simply trying anything to solve this problem at this point
public async Task<TerminalResult> ExecuteAndWaitAsync(string command, bool asRoot, CancellationToken cancellationToken = default)
{
    using Process prc = CreateNewProcess(command, asRoot);
    // we need to redirect stdstreams to read them
    prc.StartInfo.RedirectStandardOutput = true;
    prc.StartInfo.RedirectStandardError = true;

    // start the process
    _log.LogTrace("Starting the process");
    using Task waitForExitTask = WaitForExitAsync(prc, cancellationToken);
    prc.Start();

    // read streams
    string[] streamResults = await Task.WhenAll(prc.StandardOutput.ReadToEndAsync(), prc.StandardError.ReadToEndAsync()).ConfigureAwait(false);

    // wait till it fully exits, but no longer than half a second
    // this prevents hanging when process has already finished, but takes long time to fully close
    await Task.WhenAny(waitForExitTask, Task.Delay(500, cancellationToken)).ConfigureAwait(false);
    // if process still didn't exit, force kill it
    if (!prc.HasExited)
        prc.Kill(true);  // doing it with a try-catch approach instead of HasExited check gives no difference
    return new TerminalResult(streamResults[0], streamResults[1]);
}

public Task<int> WaitForExitAsync(Process process, CancellationToken cancellationToken = default)
{
    TaskCompletionSource<int> tcs = new TaskCompletionSource<int>();
    IDisposable tokenRegistration = null;
    EventHandler callback = null;
    tokenRegistration = cancellationToken.Register(() =>
    {
        Unregister();
        tcs.TrySetCanceled(cancellationToken);
    });
    callback = (sender, args) =>
    {
        Unregister();
        tcs.TrySetResult(process.ExitCode);
    };
    process.Exited += callback;
    process.EnableRaisingEvents = true;

    void Unregister()
    {
        lock (tcs)
        {
            if (tokenRegistration == null)
                return;
            process.EnableRaisingEvents = false;
            process.Exited -= callback;
            tokenRegistration?.Dispose();
            tokenRegistration = null;
        }
    }

    return tcs.Task;
}

private Process CreateNewProcess(string command, bool asRoot)
{
    _log.LogDebug("Creating process: {Command}", command);
    Process prc = new Process();

    if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
    {
        string escapedCommand = command.Replace("\"", "\\\"");
        // if as root, just sudo it
        if (asRoot)
            prc.StartInfo = new ProcessStartInfo("/bin/bash", $"-c \"sudo {escapedCommand}\"");
        // if not as root, we need to open it as current user
        // this may still run as root if the process is running as root
        else
            prc.StartInfo = new ProcessStartInfo("/bin/bash", $"-c \"{escapedCommand}\"");
    }
    else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
    {
        prc.StartInfo = new ProcessStartInfo("CMD.exe", $"/C {command}");
        if (asRoot)
            prc.StartInfo.Verb = "runas";
    }
    else
        throw new PlatformNotSupportedException($"{nameof(ExecuteAndWaitAsync)} is only supported on Windows and Linux platforms.");

    prc.StartInfo.UseShellExecute = false;
    prc.StartInfo.CreateNoWindow = true;

    if (_log.IsEnabled(LogLevel.Trace))
    {
        _log.LogTrace("exec: {FileName} {Args}", prc.StartInfo.FileName, prc.StartInfo.Arguments);
        _log.LogTrace("exec: as root = {AsRoot}", asRoot);
    }

    return prc;
}

我花了很多时间（超过几个月 - 字面意思）尝试各种更改来解决这个问题 - WaitForExitAsync 进行了很多大修，尝试了不同的处理方式。我试图定期调用 GC.Collect() 。还尝试在服务器和工作站 GC 模式下运行应用程序。

正如我之前提到的，我很确定是这段代码泄漏了——如果我不调用ExecuteAndWaitAsync，就没有内存泄漏。结果类也不由调用者存储 - 它只是解析一个值并立即使用它：

public async Task<TimeSpan> GetSystemIdleTimeAsync(CancellationToken cancellationToken = default)
{
    ThrowIfNotLinux();

    const string prc = "xprintidle";
    TerminalResult result = await _terminal.ExecuteAndWaitAsync(prc, false, cancellationToken).ConfigureAwait(false);
    if (result.HasErrors || !int.TryParse(result.Output, out int idleMs))
        throw new InvalidOperationException($"{prc} returned invalid data.");
    return TimeSpan.FromMilliseconds(idleMs);
}

private static void ThrowIfNotLinux()
{
    if (!RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
        throw new PlatformNotSupportedException($"{nameof(BacklightControl)} is only functional on Linux systems.");
}

我错过了什么吗？是进程类泄漏，还是我读取输出的方式？

编辑：正如 cmets 中的人所问，我创建了最少的可运行代码，基本上在单个类中获取所有相关方法并在循环中执行。该代码可作为要点提供：https://gist.github.com/TehGM/c953b670ad8019b2b2be6af7b14807c2
我在我的 Windows 机器和 Raspberry Pi 上都运行了它。在 Windows 上，内存似乎很稳定，但在 Raspberry Pi 上，它显然正在泄漏。我尝试了xprintidle 和ifconfig 以确保这不是仅xprintidle 的问题。 .NET Core 3.0 和 .NET Core 3.1 都试过了，效果基本一样。

Answer 1

这可能是由 .NET Core 2.2 和 .NET Core 3.0 之间的回归引起的 显然它将在版本 3.1.7 中修复

刚启动进程会导致linux上的内存泄漏，因为没有释放句柄

已在此处跟踪问题https://github.com/dotnet/runtime/issues/36661