如何强制终止Parallel.Invoke并行循环？含已启动的长时间任务

原方案中CancellationToken仅能实现协作式取消——它只会阻止Parallel.Invoke调度新的任务，却无法终止已经启动的Compute函数，因为Compute本身不响应取消信号。由于无法修改Compute的源码，只能通过进程隔离的方式强制终止超时的计算任务。

核心思路 #

将每个Compute(i)的调用放到独立的子进程中执行，当达到超时时间时，直接杀掉所有仍在运行的子进程，彻底终止计算。这种方式不受Compute内部逻辑限制，是强制终止的可靠方案。

具体实现步骤 #

1. 编写子进程程序（ComputeRunner）

创建一个控制台程序，负责接收参数并调用Compute函数：

// ComputeRunner/Program.cs
using System;

namespace ComputeRunner
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length == 1 && int.TryParse(args[0], out int i))
            {
                // 调用原项目中的Compute函数
                YourOriginalNamespace.Compute(i);
            }
        }
    }
}

将原项目中包含Compute的类编译为类库，供此子进程引用。

2. 主进程调度与超时控制

主进程负责批量启动子进程，监控超时时间，并在超时后终止所有未完成的子进程：

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        int maxTime = 60; // 自定义超时时间（秒）
        List<Process> runningProcesses = new();

        try
        {
            // 启动所有计算子进程
            for (int i = 0; i < 1000; i++)
            {
                int taskIndex = i; // 正确捕获循环变量，避免闭包问题
                Process proc = new()
                {
                    StartInfo = new ProcessStartInfo
                    {
                        FileName = "ComputeRunner.exe",
                        Arguments = taskIndex.ToString(),
                        UseShellExecute = false,
                        CreateNoWindow = true,
                        RedirectStandardOutput = false // 根据需要调整
                    }
                };
                proc.Start();
                runningProcesses.Add(proc);
            }

            // 等待所有任务完成 或 超时
            await Task.WhenAny(
                Task.WhenAll(runningProcesses.Select(p => p.WaitForExitAsync())),
                Task.Delay(TimeSpan.FromSeconds(maxTime))
            );

            // 终止所有未结束的进程
            foreach (var proc in runningProcesses)
            {
                if (!proc.HasExited)
                {
                    proc.Kill();
                    proc.WaitForExit(); // 等待进程彻底终止
                }
            }
        }
        finally
        {
            // 清理进程资源
            foreach (var proc in runningProcesses)
            {
                proc.Dispose();
            }
        }
    }
}

关键说明 #

• 进程隔离的优势：子进程与主进程完全独立，调用Kill()可以彻底终止计算，不受Compute内部逻辑的限制，是生产环境中最安全的强制终止方式。
• 开销考量：进程的创建和销毁有一定性能开销，但对于单次计算耗时数十分钟的场景，该开销可以忽略不计。
• 不推荐的替代方案：使用Thread.Abort()终止线程。这种方式会导致不可预测的资源泄漏、数据损坏，属于不安全操作，仅能在测试环境临时使用，禁止用于生产环境。

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