How to abort a Task like aborting a Thread Thread Abort method

Question

We could abort a Thread like this   Thread thread   new Thread SomeMethod         thread Abort      But can I abort a Task  in  Net 4 0  in the same way not by cancellation mechanism  I want to kill the Task immediately

User · Answer

While it s possible to abort a thread  in practice it s almost always a very bad idea to do so   Aborthing a thread means the thread is not given a chance to clean up after itself  leaving resources undeleted  and things in unknown states     In practice  if you abort a thread  you should only do so in conjunction with killing the process   Sadly  all too many people think ThreadAbort is a viable way of stopping something and continuing on  it s not   Since Tasks run as threads  you can call ThreadAbort on them  but as with generic threads you almost never want to do this  except as a last resort

User · Answer

You can  abort  a task by running it on a thread you control and aborting that thread  This causes the task to complete in a faulted state with a ThreadAbortException  You can control thread creation with a custom task scheduler  as described in this answer  Note that the caveat about aborting a thread applies    If you don t ensure the task is created on its own thread  aborting it would abort either a thread-pool thread or the thread initiating the task  neither of which you typically want to do

User · Answer

If you have Task constructor  then we may extract Thread from the Task  and invoke thread abort   Thread th   null   Task Factory StartNew      gt        th   Thread CurrentThread       while  true                Console WriteLine DateTime UtcNow              Thread Sleep 2000   th Abort    Console ReadKey

User · Answer

But can I abort a Task  in  Net 4 0  in the same way not by   cancellation mechanism  I want to kill the Task immediately    Other answerers have told you not to do it   But yes  you can do it   You can supply Thread Abort   as the delegate to be called by the Task s cancellation mechanism   Here is how you could configure this   class HardAborter     public bool WasAborted   get  private set      private CancellationTokenSource Canceller   get  set      private Task lt object gt  Worker   get  set       public void Start Func lt object gt  DoFunc          WasAborted   false          start a task with a means to do a hard abort  unsafe       Canceller   new CancellationTokenSource         Worker   Task Factory StartNew      gt                   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             disclaimer  don t do this   Here is an example of what not to do    var doNotDoThis   new HardAborter         start a thread writing to the console  doNotDoThis Start      gt               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

User · Answer

The guidance on not using a thread abort is controversial  I think there is still a place for it but in exceptional circumstance  However you should always attempt to design around it and see it as a last resort    Example   You have a simple windows form application that connects to a blocking synchronous web service  Within which it executes a function on the web service within a Parallel loop     CancellationTokenSource cts   new CancellationTokenSource    ParallelOptions po   new ParallelOptions    po CancellationToken   cts Token  po MaxDegreeOfParallelism   System Environment ProcessorCount   Parallel ForEach iListOfItems  po   item  loopState    gt         Thread Sleep 120000      pretend web service call        Say in this example  the blocking call takes 2 mins to complete  Now I set my MaxDegreeOfParallelism to say ProcessorCount   iListOfItems has 1000 items within it to process   The user clicks the process button and the loop commences  we have  up-to  20 threads executing against 1000 items in the iListOfItems collection  Each iteration executes on its own thread  Each thread will utilise a foreground thread when created by Parallel ForEach  This means regardless of the main application shutdown  the app domain will be kept alive until all threads have finished   However the user needs to close the application for some reason  say they close the form  These 20 threads will continue to execute until all 1000 items are processed  This is not ideal in this scenario  as the application will not exit as the user expects and will continue to run behind the scenes  as can be seen by taking a look in task manger    Say the user tries to rebuild the app again  VS 2010   it reports the exe is locked  then  they would have to go into task manager to kill it or just wait until all 1000 items are processed    I would not blame you for saying  but of course  I should be cancelling these threads using the CancellationTokenSource object and calling Cancel     but there are some problems with this as of  net 4 0  Firstly this is still never going to result in a thread abort which would offer up an abort exception followed by thread termination  so the app domain will instead need to wait for the threads to finish normally  and this means waiting for the last blocking call  which would be the very last running iteration  thread  that ultimately gets to call po CancellationToken ThrowIfCancellationRequested  In the example this would mean the app domain could still stay alive for up to 2 mins  even though the form has been closed and cancel called     Note that Calling Cancel on CancellationTokenSource does not throw an exception on the processing thread s   which would indeed act to interrupt the blocking call similar to a thread abort and stop the execution  An exception is cached ready for when all the other threads  concurrent iterations  eventually finish and return  the exception is thrown in the initiating thread  where the loop is declared    I chose not to use the Cancel option on a CancellationTokenSource object  This is wasteful and arguably violates the well known anti-patten of controlling the flow of the code by Exceptions   Instead  it is arguably  better  to implement a simple thread safe property i e  Bool stopExecuting  Then within the loop  check the value of stopExecuting and if the value is set to true by the external influence   we can take an alternate path to close down gracefully   Since we should not call cancel  this precludes checking CancellationTokenSource IsCancellationRequested which would otherwise be another option   Something like the following if condition would be appropriate within the loop      if  loopState ShouldExitCurrentIteration    loopState IsExceptional    stopExecuting   loopState Stop    return     The iteration will now exit in a  controlled  manner as well as terminating further iterations  but as I said  this does little for our issue of having to wait on the long running and blocking call s  that are made within each iteration  parallel loop thread   since these have to complete before each thread can get to the option of checking if it should stop    In summary  as the user closes the form  the 20 threads will be signaled to stop via stopExecuting  but they will only stop when they have finished executing their long running function call   We can t do anything about the fact that the application domain will always stay alive and only be released when all foreground threads have completed  And this means there will be a delay associated with waiting for any blocking calls made within the loop to complete    Only a true thread abort can interrupt the blocking call  and you must mitigate leaving the system in a unstable undefined state the best you can in the aborted thread s exception handler which goes without question  Whether that s appropriate is a matter for the programmer to decide  based on what resource handles they chose to maintain and how easy it is to close them in a thread s finally block  You could register with a token to terminate on cancel as a semi workaround i e    CancellationTokenSource cts   new CancellationTokenSource    ParallelOptions po   new ParallelOptions    po CancellationToken   cts Token  po MaxDegreeOfParallelism   System Environment ProcessorCount   Parallel ForEach iListOfItems  po   item  loopState    gt         using  cts Token Register Thread CurrentThread Abort                 Try                      Thread Sleep 120000      pretend web service call                             Catch ThreadAbortException ex                          log etc                    Finally                        clean up here                        but this will still result in an exception in the declaring thread    All things considered  interrupt blocking calls using the parallel loop constructs could have been a method on the options  avoiding the use of more obscure parts of the library  But why there is no option to cancel and avoid throwing an exception in the declaring method strikes me as a possible oversight

User · Answer

You shouldn t use Thread Abort   Tasks can be Cancelled but not aborted     The Thread Abort   method is  severely  deprecated   Both Threads and Tasks should cooperate when being stopped  otherwise you run the risk of leaving the system in a unstable undefined state    If you do need to run a Process and kill it from the outside  the only safe option is to run it in a separate AppDomain     This answer is about  net 3 5 and earlier   Thread-abort handling has been improved since then  a o  by changing the way finally blocks work    But Thread Abort is still a suspect solution that you should always try to avoid

User · Answer

Everyone knows  hopefully  its bad to terminate thread  The problem is when you don t own a piece of code you re calling  If this code is running in some do while infinite loop   itself calling some native functions  etc  you re basically stuck  When this happens in your own code termination  stop or Dispose call  it s kinda ok to start shooting the bad guys  so you don t become a bad guy yourself    So  for what it s worth  I ve written those two blocking functions that use their own native thread  not a thread from the pool or some thread created by the CLR  They will stop the thread if a timeout occurs      returns true if the call went to completion successfully  false otherwise public static bool RunWithAbort this Action action  int milliseconds    gt  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      gt                using  source Token Register      gt  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 lt T gt  this Func lt T gt  func  int milliseconds    gt  RunWithAbort func  new TimeSpan 0  0  0  0  milliseconds    public static T RunWithAbort lt T gt  this Func lt T gt  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      gt                using  source Token Register      gt  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

User · Answer

using System  using System Threading  using System Threading Tasks        var cts   new CancellationTokenSource    var task   Task Run      gt    while  true          Parallel Invoke      gt        task Wait cts Token           gt        Thread Sleep 1000       cts Cancel          This is a simple snippet to abort a never-ending task with CancellationTokenSource

[c#] How to abort a Task like aborting a Thread (Thread.Abort method)?

Examples related to c#

Examples related to .net

Examples related to parallel-processing

Examples related to .net-4.0