如何像中止线程一样中止任务（Thread.Abort 方法）？

Question

我们可以像这样中止一个Thread：

Thread thread = new Thread(SomeMethod);
.
.
.
thread.Abort();

但是我可以以同样的方式而不是通过取消机制来中止一个Task（在.Net 4.0中）吗？ 我想立即终止任务。

Answer 1

关于不使用线程中止的指导是有争议的。我认为它仍然有一席之地，但在特殊情况下。但是，您应该始终尝试围绕它进行设计，并将其视为最后的手段。

例子;

您有一个简单的 Windows 窗体应用程序，它连接到阻塞同步 Web 服务。它在并行循环中执行 Web 服务上的函数。

CancellationTokenSource cts = new CancellationTokenSource();
ParallelOptions po = new ParallelOptions();
po.CancellationToken = cts.Token;
po.MaxDegreeOfParallelism = System.Environment.ProcessorCount;

Parallel.ForEach(iListOfItems, po, (item, loopState) =>
{

    Thread.Sleep(120000); // pretend web service call

});

在此示例中，阻塞调用需要 2 分钟才能完成。现在我将 MaxDegreeOfParallelism 设置为 ProcessorCount。 iListOfItems 有 1000 个项目需要处理。

用户单击进程按钮，循环开始，我们最多有 20 个线程针对 iListOfItems 集合中的 1000 个项目执行。每次迭代都在其自己的线程上执行。每个线程在由 Parallel.ForEach 创建时都将利用一个前台线程。这意味着无论主应用程序关闭如何，应用程序域都将保持活动状态，直到所有线程完成。

但是，用户由于某种原因需要关闭应用程序，例如关闭表单。
这 20 个线程将继续执行，直到处理完所有 1000 个项目。在这种情况下，这并不理想，因为应用程序不会按用户期望的那样退出，而是会继续在幕后运行，通过查看任务管理器可以看出。

假设用户尝试再次重建应用程序（VS 2010），它报告 exe 被锁定，然后他们必须进入任务管理器来终止它，或者只是等待所有 1000 个项目都被处理。

我不会责怪你这么说，但当然！我应该使用 CancellationTokenSource 对象并调用 Cancel ...但是从 .net 4.0 开始，这存在一些问题。首先，这仍然永远不会导致线程中止，这会在线程终止后提供中止异常，因此应用程序域将需要等待线程正常完成，这意味着等待最后一个阻塞调用，这将是最终调用 po.CancellationToken.ThrowIfCancellationRequested 的最后一个正在运行的迭代（线程）。
在示例中，这意味着应用程序域仍然可以保持活动状态长达 2 分钟，即使表单已关闭并取消调用。

请注意，在 CancellationTokenSource 上调用 Cancel 不会在处理线程上引发异常，这实际上会中断阻塞调用，类似于线程中止并停止执行。异常会被缓存，以便当所有其他线程（并发迭代）最终完成并返回时，该异常将在启动线程（声明循环的位置）中抛出。

我选择不使用

相反，实现一个简单的线程安全属性（即 Bool stopExecuting）可以说“更好”。然后在循环中检查stopExecuting的值，如果该值因外部影响而设置为true，我们可以采取替代路径优雅地关闭。由于我们不应该调用取消，这会阻止检查 CancellationTokenSource.IsCancellationRequested 这将是另一种选择。

类似下面的 if 条件在循环中是合适的；

if (loopState.ShouldExitCurrentIteration || LoopState.IsExceptional || stopExecuting) {loopState.Stop();返回；}

，迭代将以“受控”方式退出，并终止进一步的迭代，但正如我所说，这对于我们必须等待长时间运行和阻塞调用的问题没有什么帮助。每次迭代（并行循环线程），因为这些必须在每个线程可以选择检查是否应该停止之前完成。

总之，当用户关闭表单时，20 个线程将通过 stopExecuting 收到停止信号，但它们只有在执行完长时间运行的函数调用后才会停止。

对于应用程序域将始终保持活动状态并且仅在所有前台线程完成后才被释放的事实，我们无能为力。这意味着等待循环内进行的任何阻塞调用完成都会产生延迟。

只有真正的线程中止才能中断阻塞调用，并且您必须在中止线程的异常处理程序中尽最大努力减轻系统处于不稳定/未定义状态的情况，这是毫无疑问的。这是否合适是程序员需要根据他们选择维护的资源句柄以及在线程的finally块中关闭它们的容易程度来决定的。您可以注册一个令牌以在取消时终止，作为半解决方法，

CancellationTokenSource cts = new CancellationTokenSource();
ParallelOptions po = new ParallelOptions();
po.CancellationToken = cts.Token;
po.MaxDegreeOfParallelism = System.Environment.ProcessorCount;

Parallel.ForEach(iListOfItems, po, (item, loopState) =>
{

    using (cts.Token.Register(Thread.CurrentThread.Abort))
    {
        Try
        {
           Thread.Sleep(120000); // pretend web service call          
        }
        Catch(ThreadAbortException ex)
        {
           // log etc.
        }
        Finally
        {
          // clean up here
        }
    }

});

但这仍然会导致声明线程中出现异常。

考虑到所有因素，使用parallel.loop 构造的中断阻塞调用可能是选项上的一种方法，避免使用库中更模糊的部分。但为什么在声明方法中没有取消和避免抛出异常的选项，我觉得这可能是一个疏忽。

Answer 2

但是我可以以同样的方式中止任务（在.Net 4.0中）而不是通过
取消机制。 我想立即终止任务。

其他回答者告诉你不要这样做。但是，是的，您可以做到。您可以提供Thread.Abort()作为任务取消机制调用的委托。以下是配置方法：

class HardAborter
{
  public bool WasAborted { get; private set; }
  private CancellationTokenSource Canceller { get; set; }
  private Task<object> Worker { get; set; }

  public void Start(Func<object> DoFunc)
  {
    WasAborted = false;

    // start a task with a means to do a hard abort (unsafe!)
    Canceller = new CancellationTokenSource();

    Worker = Task.Factory.StartNew(() => 
      {
        try
        {
          // specify this thread's Abort() as the cancel delegate
          using (Canceller.Token.Register(Thread.CurrentThread.Abort))
          {
            return DoFunc();
          }
        }
        catch (ThreadAbortException)
        {
          WasAborted = true;
          return false;
        }
      }, Canceller.Token);
  }

  public void Abort()
  {
    Canceller.Cancel();
  }

}

免责声明：不要这样做。

以下是不应该做的事情的示例：

 var doNotDoThis = new HardAborter();

 // start a thread writing to the console
 doNotDoThis.Start(() =>
    {
       while (true)
       {
          Thread.Sleep(100);
          Console.Write(".");
       }
       return null;
    });


 // wait a second to see some output and show the WasAborted value as false
 Thread.Sleep(1000);
 Console.WriteLine("WasAborted: " + doNotDoThis.WasAborted);

 // wait another second, abort, and print the time
 Thread.Sleep(1000);
 doNotDoThis.Abort();
 Console.WriteLine("Abort triggered at " + DateTime.Now);

 // wait until the abort finishes and print the time
 while (!doNotDoThis.WasAborted) { Thread.CurrentThread.Join(0); }
 Console.WriteLine("WasAborted: " + doNotDoThis.WasAborted + " at " + DateTime.Now);

 Console.ReadKey();

Answer 3

1. 您不应该使用 Thread.Abort()
2. 任务可以取消但不能中止。

Thread.Abort() 方法已（严重）弃用。

线程和任务在停止时都应该合作，否则您将面临使系统处于不稳定/未定义状态的风险。

如果您确实需要运行进程并从外部终止它，唯一安全的选择是在单独的 AppDomain 中运行它。

---

这个答案是关于 .net 3.5 及更早版本的。

从那时起，通过改变finally 块的工作方式，线程中止处理得到了改进。

但 Thread.Abort 仍然是一个值得怀疑的解决方案，您应该始终尽量避免。

---

在 .net Core (.net 5+) 中，Thread.Abort() 现在将抛出 PlatformNotSupportedException 。

有点强调“已弃用”的观点。

Answer 4

每个人都知道（希望）终止线程是不好的。问题是当您不拥有您正在调用的一段代码时。如果这段代码在某些 do/while 无限循环中运行，它本身调用一些本机函数等，那么您基本上就陷入困境了。当这种情况发生在您自己的代码终止、停止或 Dispose 调用中时，开始射击坏人就可以了（这样您自己就不会成为坏人）。

因此，无论如何，我编写了这两个阻塞函数，它们使用自己的本机线程，而不是池中的线程或 CLR 创建的某个线程。如果发生超时，他们将停止线程：

// returns true if the call went to completion successfully, false otherwise
public static bool RunWithAbort(this Action action, int milliseconds) => RunWithAbort(action, new TimeSpan(0, 0, 0, 0, milliseconds));
public static bool RunWithAbort(this Action action, TimeSpan delay)
{
    if (action == null)
        throw new ArgumentNullException(nameof(action));

    var source = new CancellationTokenSource(delay);
    var success = false;
    var handle = IntPtr.Zero;
    var fn = new Action(() =>
    {
        using (source.Token.Register(() => TerminateThread(handle, 0)))
        {
            action();
            success = true;
        }
    });

    handle = CreateThread(IntPtr.Zero, IntPtr.Zero, fn, IntPtr.Zero, 0, out var id);
    WaitForSingleObject(handle, 100 + (int)delay.TotalMilliseconds);
    CloseHandle(handle);
    return success;
}

// returns what's the function should return if the call went to completion successfully, default(T) otherwise
public static T RunWithAbort<T>(this Func<T> func, int milliseconds) => RunWithAbort(func, new TimeSpan(0, 0, 0, 0, milliseconds));
public static T RunWithAbort<T>(this Func<T> func, TimeSpan delay)
{
    if (func == null)
        throw new ArgumentNullException(nameof(func));

    var source = new CancellationTokenSource(delay);
    var item = default(T);
    var handle = IntPtr.Zero;
    var fn = new Action(() =>
    {
        using (source.Token.Register(() => TerminateThread(handle, 0)))
        {
            item = func();
        }
    });

    handle = CreateThread(IntPtr.Zero, IntPtr.Zero, fn, IntPtr.Zero, 0, out var id);
    WaitForSingleObject(handle, 100 + (int)delay.TotalMilliseconds);
    CloseHandle(handle);
    return item;
}

[DllImport("kernel32")]
private static extern bool TerminateThread(IntPtr hThread, int dwExitCode);

[DllImport("kernel32")]
private static extern IntPtr CreateThread(IntPtr lpThreadAttributes, IntPtr dwStackSize, Delegate lpStartAddress, IntPtr lpParameter, int dwCreationFlags, out int lpThreadId);

[DllImport("kernel32")]
private static extern bool CloseHandle(IntPtr hObject);

[DllImport("kernel32")]
private static extern int WaitForSingleObject(IntPtr hHandle, int dwMilliseconds);

Answer 5

虽然可以中止线程，但实际上这样做几乎总是一个非常糟糕的主意。中止线程意味着线程没有机会自行清理，从而使资源未被删除，并且事物处于未知状态。

实际上，如果中止线程，则应该仅在终止进程的同时执行此操作。可悲的是，太多人认为 ThreadAbort 是停止某些事情并继续执行的可行方法，但事实并非如此。

由于任务作为线程运行，因此您可以对它们调用 ThreadAbort，但与通用线程一样，您几乎不想这样做，除非作为最后的手段。

Answer 6

您可以通过在您控制的线程上运行任务并中止该线程来“中止”任务。这会导致任务在错误状态下完成，并出现 ThreadAbortException 。您可以使用自定义任务计划程序控制线程创建，如此答案中所述。请注意有关中止线程的警告 适用。

（如果您不确保该任务是在其自己的线程上创建的，则中止该任务将中止线程池线程或启动该任务的线程，而您通常不想这样做。）

Answer 7

我在 Excel 的 Application.Workbooks 中遇到了类似的问题。

如果应用程序繁忙，该方法将永远挂起。我的方法只是尝试将其放入任务中并等待，如果花费太长时间，我就将任务保留并离开（没有坏处“在这种情况下”，Excel 会在用户完成忙碌的事情时解冻）。

在这种情况下，不可能使用取消令牌。优点是我不需要过多的代码、中止线程等。

public static List<Workbook> GetAllOpenWorkbooks()
{
    //gets all open Excel applications
    List<Application> applications = GetAllOpenApplications();

    //this is what we want to get from the third party library that may freeze
    List<Workbook> books = null;

    //as Excel may freeze here due to being busy, we try to get the workbooks asynchronously
    Task task = Task.Run(() =>
    {
        try 
        { 
            books = applications
                .SelectMany(app => app.Workbooks.OfType<Workbook>()).ToList();
        }
        catch { }
    });
    
    //wait for task completion
    task.Wait(5000);
    return books; //handle outside if books is null
}

Answer 8

这是我对 @Simon-Mourier 提出的想法的实现，使用 dotnet 线程，代码简短：

    public static bool RunWithAbort(this Action action, int milliseconds)
    {
         if (action == null) throw new ArgumentNullException(nameof(action));

        var success = false;
        var thread = new Thread(() =>
        {
            action();
            success = true;
        });
        thread.IsBackground = true;
        thread.Start();
        thread.Join(milliseconds);          
        thread.Abort();

        return success;
    }

Answer 9

using System;
using System.Threading;
using System.Threading.Tasks;

...

var cts = new CancellationTokenSource();
var task = Task.Run(() => { while (true) { } });
Parallel.Invoke(() =>
{
    task.Wait(cts.Token);
}, () =>
{
    Thread.Sleep(1000);
    cts.Cancel();
});

这是一个简单的代码片段，用于使用 CancellationTokenSource。