Pozastavení a přerušení vláken

Nejběžnějšími způsoby synchronizace aktivit vláken jsou blokování a vydávání vláken nebo uzamčení objektů nebo oblastí kódu. Další informace o těchto mechanismech uzamčení a blokování najdete v tématu Přehled primitiv synchronizace.

Můžete také nechat vlákna přejít do režimu spánku. Když jsou vlákna blokována nebo spí, můžete k jejich přerušení ze stavu čekání použít ThreadInterruptedException.

Metoda Thread.Sleep

Volání metody Thread.Sleep způsobí, že aktuální vlákno se okamžitě zablokuje na počet milisekund nebo po časový interval, který metodě zadáte, a předá zbývající část svého časového řezu jinému vláknu. Jakmile tento interval uplyne, uspáné vlákno pokračuje v provádění.

Jedno vlákno nemůže volat Thread.Sleep v jiném vlákně. Thread.Sleep je statická metoda, která vždy způsobí, že aktuální vlákno spí.

Volání Thread.Sleep s hodnotou Timeout.Infinite způsobí, že vlákno spí, dokud jiný vlákno nevolá metodu Thread.Interrupt ve vlákně spánku. Následující příklad znázorňuje přerušení spícího vlákna.

using System;
using System.Threading;

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

    private static void SleepIndefinitely()
    {
        Console.WriteLine($"Thread '{Thread.CurrentThread.Name}' about to sleep indefinitely.");
        try
        {
            Thread.Sleep(Timeout.Infinite);
        }
        catch (ThreadInterruptedException)
        {
            Console.WriteLine($"Thread '{Thread.CurrentThread.Name}' awoken.");
        }
        finally
        {
            Console.WriteLine($"Thread '{Thread.CurrentThread.Name}' executing finally block.");
        }
        Console.WriteLine($"Thread '{Thread.CurrentThread.Name}' finishing normal execution.");
        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.

Imports System.Threading

Module Example
    Public Sub Main()
        ' Interrupt a sleeping thread.
        Dim sleepingThread = New Thread(AddressOf SleepIndefinitely)
        sleepingThread.Name = "Sleeping"
        sleepingThread.Start()
        Thread.Sleep(2000)
        sleepingThread.Interrupt()
        sleepingThread.Join()
    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)
        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.

Příklad volá funkci Thread.Join, která zablokuje volající vlákno, dokud vlákno, které bylo přerušeno, nedokončí provádění.

Přerušení vláken

Můžete přerušit čekající vlákno tím, že zavoláte metodu Thread.Interrupt na blokovaném vlákně a vyvoláte ThreadInterruptedException, což uvolní vlákno z blokujícího volání. Vlákno by mělo zachytit ThreadInterruptedException a udělat vše, aby pokračovalo v práci. Pokud vlákno tuto výjimku ignoruje, modul runtime výjimku zachytí a zastaví vlákno.

Poznámka:

Pokud cílové vlákno není blokováno, když je Thread.Interrupt voláno, vlákno není přerušeno, dokud se nezablokuje. Pokud vlákno nikdy nezablokuje, mohlo by se dokončit bez přerušení.

Pokud je čekání spravované čekání, Thread.Interrupt okamžitě probudí vlákno. Pokud je čekání nespravované čekání (například volání platformy funkce Win32 WaitForSingleObject), Thread.Interrupt nemůže převzít kontrolu nad vláknem, dokud se vláknu nevrátí řízení, aby mohlo pracovat se spravovaným kódem. Ve spravovaném kódu je chování následující:

Viz také

  • Last updated on