İş parçacıklarını duraklatma ve kesintiye uğratma

  • Makale

İş parçacıklarının etkinliklerini eşitlemenin en yaygın yolları, iş parçacıklarını engellemek ve serbest bırakmak ya da nesneleri veya kod bölgelerini kilitlemektir. Bu kilitleme ve engelleme mekanizmaları hakkında daha fazla bilgi için bkz . Eşitleme Temel Bilgilerine Genel Bakış.

Ayrıca, iş parçacıklarının kendilerini uyku moduna geçirmelerini sağlayabilirsiniz. İş parçacıkları engellendiğinde veya uykuda olduğunda, bekleme durumlarından ayırmak için bir ThreadInterruptedException kullanabilirsiniz.

Thread.Sleep yöntemi

yöntemini çağırmak Thread.Sleep , geçerli iş parçacığının milisaniye veya yönteme geçirdiğiniz zaman aralığı için hemen engellemesine neden olur ve zaman diliminin kalan kısmını başka bir iş parçacığına verir. Bu aralık geçtikten sonra, uyku iş parçacığı yürütmeyi sürdürür.

Bir iş parçacığı başka bir iş parçacığında çağrı Thread.Sleep yapamaz. Thread.Sleep her zaman geçerli iş parçacığının uyku moduna neden olan statik bir yöntemdir.

değeriyle çağırmak Thread.Sleep , bir iş parçacığının Timeout.Infinite uyku iş parçacığında yöntemini çağıran Thread.Interrupt başka bir iş parçacığı tarafından kesilene kadar veya yöntemine yapılan bir çağrıyla sonlandırılana kadar uyku moduna neden Thread.Abort olur. Aşağıdaki örnekte, uyuyan bir iş parçacığını kesmenin her iki yöntemi de gösterilmektedir.

using System;
using System.Threading;

public class Example
{
   public static void Main()
   {
      // Interrupt a sleeping thread.
      var sleepingThread = new Thread(Example.SleepIndefinitely);
      sleepingThread.Name = "Sleeping";
      sleepingThread.Start();
      Thread.Sleep(2000);
      sleepingThread.Interrupt();

      Thread.Sleep(1000);

      sleepingThread = new Thread(Example.SleepIndefinitely);
      sleepingThread.Name = "Sleeping2";
      sleepingThread.Start();
      Thread.Sleep(2000);
      sleepingThread.Abort();
   }

   private static void SleepIndefinitely()
   {
      Console.WriteLine("Thread '{0}' about to sleep indefinitely.",
                        Thread.CurrentThread.Name);
      try {
         Thread.Sleep(Timeout.Infinite);
      }
      catch (ThreadInterruptedException) {
         Console.WriteLine("Thread '{0}' awoken.",
                           Thread.CurrentThread.Name);
      }
      catch (ThreadAbortException) {
         Console.WriteLine("Thread '{0}' aborted.",
                           Thread.CurrentThread.Name);
      }
      finally
      {
         Console.WriteLine("Thread '{0}' executing finally block.",
                           Thread.CurrentThread.Name);
      }
      Console.WriteLine("Thread '{0} finishing normal execution.",
                        Thread.CurrentThread.Name);
      Console.WriteLine();
   }
}
// The example displays the following output:
//       Thread 'Sleeping' about to sleep indefinitely.
//       Thread 'Sleeping' awoken.
//       Thread 'Sleeping' executing finally block.
//       Thread 'Sleeping finishing normal execution.
//
//       Thread 'Sleeping2' about to sleep indefinitely.
//       Thread 'Sleeping2' aborted.
//       Thread 'Sleeping2' executing finally block.

Imports System.Threading

Module Example
    Public Sub Main()
        ' Interrupt a sleeping thread. 
        Dim sleepingThread = New Thread(AddressOf Example.SleepIndefinitely)
        sleepingThread.Name = "Sleeping"
        sleepingThread.Start()
        Thread.Sleep(2000)
        sleepingThread.Interrupt()

        Thread.Sleep(1000)

        sleepingThread = New Thread(AddressOf Example.SleepIndefinitely)
        sleepingThread.Name = "Sleeping2"
        sleepingThread.Start()
        Thread.Sleep(2000)
        sleepingThread.Abort()
    End Sub

    Private Sub SleepIndefinitely()
        Console.WriteLine("Thread '{0}' about to sleep indefinitely.",
                          Thread.CurrentThread.Name)
        Try
            Thread.Sleep(Timeout.Infinite)
        Catch ex As ThreadInterruptedException
            Console.WriteLine("Thread '{0}' awoken.",
                              Thread.CurrentThread.Name)
        Catch ex As ThreadAbortException
            Console.WriteLine("Thread '{0}' aborted.",
                              Thread.CurrentThread.Name)
        Finally
            Console.WriteLine("Thread '{0}' executing finally block.",
                              Thread.CurrentThread.Name)
        End Try
        Console.WriteLine("Thread '{0} finishing normal execution.",
                          Thread.CurrentThread.Name)
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'       Thread 'Sleeping' about to sleep indefinitely.
'       Thread 'Sleeping' awoken.
'       Thread 'Sleeping' executing finally block.
'       Thread 'Sleeping finishing normal execution.
'       
'       Thread 'Sleeping2' about to sleep indefinitely.
'       Thread 'Sleeping2' aborted.
'       Thread 'Sleeping2' executing finally block.

İş parçacıklarını kesme

Engellenen iş parçacığında Thread.Interrupt yöntemini çağırarak bekleyen bir iş parçacığını ThreadInterruptedExceptionkesebilir ve bu da iş parçacığını engelleyici çağrıdan çıkarır. İş parçacığının öğesini yakalaması ThreadInterruptedException ve çalışmaya devam etmek için uygun olan her şeyi yapması gerekir. İş parçacığı özel durumu yoksayarsa, çalışma zamanı özel durumu yakalar ve iş parçacığını durdurur.

Not

Hedef iş parçacığı çağrıldığında Thread.Interrupt engellenmiyorsa, iş parçacığı engellenene kadar kesintiye uğramaz. İş parçacığı hiçbir zaman engellemezse, kesintiye uğramadan tamamlanabilir.

Bekleme, yönetilen bir bekleme Thread.Interrupt ise ve Thread.Abort her ikisi de iş parçacığını hemen uyandırır. Bekleme, yönetilmeyen bir bekleme ise (örneğin, bir platform Win32 WaitForSingleObject işlevine çağrı çağırır), yönetilen Thread.InterruptThread.Abort koda dönene veya kodu çağırana kadar iş parçacığının denetimini alamaz. Yönetilen kodda davranış aşağıdaki gibidir:

Ayrıca bkz.