Forcefully terminate thread generated by Parallel.ForEach

Question

When using Parallel.ForEach(), is there a way to forcefully execute Thread.Abort on a specific thread?

I know that Thread.Abort() is not recommended.

I'm running a Parallel.ForEach() on a collection of a hundreds of thousands of entities.

The loop processes data going back 30 years in some cases. We've had a few issues where a thread hangs. While we are trying to get a grasp on that, was hoping to call implement a fail safe. If the thread runs for more than x amount of time, forcefully kill the thread.

I do not want to use a cancellation token.

It would be ugly, but haven't come to another solution. Would it be possible to:

• Have each thread open a timer. Pass in reference of Thread.CurrentThread to timer
• If the timer elapses, and processing hasn’t completed, call Thread.Abort on that timer
• If needed, signal event wait handle to allow next patient to process

private void ProcessEntity(ProcessParams param,
    ConcurrentDictionary<long, string> entities)
{
    var options = new ParallelOptions
    {
        MaxDegreeOfParallelism = 2
    };
    Parallel.ForEach(person, options, p =>
    {
        ProcessPerson(param, p);
    });
}

internal void ProcessPerson(ProcessParams param, KeyValuePair<long, string> p)
{
    try
    {
        //...
    }
    catch (Exception ex)
    {

    }
    param.eventWaitHandle?.WaitOne();
}

Answer 1

It seems that the Parallel.ForEach method is not resilient in the face of its worker threads being aborted, and behaves inconsistently. Other times propagates an AggregateException that contains the ThreadAbortException, and other times it throws an ThreadAbortException directly, with an ugly stack trace revealing its internals.

Below is a custom ForEachTimeoutAbort method that offers the basic functionality of the Parallel.ForEach, without advanced features like cancellation, loop state, custom partitioners etc. Its special feature is the TimeSpan timeout parameter, that aborts the worker thread of any item that takes too long to complete.

public static void ForEachTimeoutAbort<TSource>(
    this IEnumerable<TSource> source,
    Action<TSource> action,
    int maxDegreeOfParallelism,
    TimeSpan timeout)
{
    // Arguments validation omitted
    var semaphore = new SemaphoreSlim(maxDegreeOfParallelism, maxDegreeOfParallelism);
    var exceptions = new ConcurrentQueue<Exception>();
    try
    {
        foreach (var item in source)
        {
            semaphore.Wait();
            if (!exceptions.IsEmpty) { semaphore.Release(); break; }

            ThreadPool.QueueUserWorkItem(_ =>
            {
                var timer = new Timer(state => ((Thread)state).Abort(),
                    Thread.CurrentThread, Timeout.Infinite, Timeout.Infinite);
                try
                {
                    timer.Change(timeout, Timeout.InfiniteTimeSpan);
                    action(item);
                }
                catch (Exception ex) { exceptions.Enqueue(ex); }
                finally
                {
                    using (var waitHandle = new ManualResetEvent(false))
                    {
                        timer.Dispose(waitHandle);
                        // Wait the timer's callback (if it's queued) to complete.
                        waitHandle.WaitOne();
                    }
                    semaphore.Release();
                }
            });
        }
    }
    catch (Exception ex) { exceptions.Enqueue(ex); }

    // Wait for all pending operations to complete
    for (int i = 0; i < maxDegreeOfParallelism; i++) semaphore.Wait();
    if (!exceptions.IsEmpty) throw new AggregateException(exceptions);
}

A peculiarity of the ThreadAbortException is that it cannot be caught. So in order to prevent the premature completion of the parallel loop, the Thread.ResetAbort method must be called from the catch block.

Usage example:

ForEachTimeoutAbort(persons, p =>
{
    try
    {
        ProcessPerson(param, p);
    }
    catch (ThreadAbortException)
    {
        Thread.ResetAbort();
    }
}, maxDegreeOfParallelism: 2, timeout: TimeSpan.FromSeconds(30));

The .NET Framework is the only platform where the ForEachTimeoutAbort method could be used. For .NET Core and .NET 5 one could try converting it to ForEachTimeoutInterrupt, and replace the call to Abort with a call to Interrupt. Interrupting a thread is not as effective as aborting it, because it only has effect when the thread is in a waiting/sleeping mode. But it may be sufficient in some scenarios.