Bagikan melalui

Menghentikan sementara dan menginterupsi utas

Cara paling umum untuk menyinkronkan aktivitas utas adalah dengan memblokir dan melepaskan utas, atau mengunci objek atau wilayah kode. Untuk informasi selengkapnya tentang mekanisme penguncian dan pemblokiran ini, lihat Gambaran Umum Primitif Sinkronisasi.

Anda juga dapat memiliki utas membuat diri mereka tidur. Ketika utas diblokir atau tidur, Anda dapat menggunakan ThreadInterruptedException untuk membebaskan mereka dari keadaan menunggu.

Metode Thread.Sleep

Memanggil metode Thread.Sleep menyebabkan utas saat ini segera menghentikan selama jumlah milidetik atau interval waktu yang Anda berikan ke metode, dan menyerahkan sisa waktu proses ke utas lain. Setelah interval itu berlalu, benang tidur akan melanjutkan eksekusi.

Satu utas tidak dapat memanggil Thread.Sleep pada utas lain. Thread.Sleep adalah metode statis yang selalu menyebabkan utas saat ini berhenti sejenak.

Memanggil Thread.Sleep dengan nilai Timeout.Infinite menyebabkan utas tidur hingga utas lain memanggil metode Thread.Interrupt pada utas yang tidur. Contoh berikut mengilustrasikan mengganggu utas tidur.

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.

Contoh memanggil Thread.Join untuk memblokir utas yang menelepon sampai utas yang terganggu menyelesaikan eksekusinya.

Menghentikan sementara benang

Anda dapat menginterupsi thread yang sedang menunggu dengan memanggil metode Thread.Interrupt pada thread yang terblokir untuk melemparkan ThreadInterruptedException, yang menyebabkan thread keluar dari panggilan pemblokiran. Utas harus menangkap ThreadInterruptedException dan melakukan apa pun yang sesuai untuk terus bekerja. Jika thread mengabaikan pengecualian, runtime akan menangkap pengecualian dan menghentikan thread.

Nota

Jika thread target tidak diblokir saat Thread.Interrupt dipanggil, thread tersebut tidak akan terganggu sampai thread tersebut diblokir. Jika utas tidak pernah diblokir, itu bisa selesai tanpa pernah diputus.

Jika penantian adalah penantian yang dikelola, maka Thread.Interrupt segera membangunkan utas. Jika penantian adalah penantian yang tidak dikelola (misalnya, platform memanggil fungsi Win32 WaitForSingleObject), Thread.Interrupt tidak dapat mengontrol utas sampai kembali ke atau memanggil kode terkelola. Dalam kode terkelola, perilakunya adalah sebagai berikut:

Baca juga

  • Last updated on