Kelas System.Threading.Thread

Artikel ini menyediakan keterangan tambahan untuk dokumentasi referensi untuk API ini.

Kelas Thread membuat dan mengontrol utas, menetapkan prioritasnya, dan mendapatkan statusnya.

Ketika proses dimulai, runtime bahasa umum secara otomatis membuat satu utas latar depan untuk menjalankan kode aplikasi. Seiring dengan utas latar depan utama ini, proses dapat membuat satu atau beberapa utas untuk menjalankan sebagian kode program yang terkait dengan proses. Utas ini dapat dijalankan baik di latar depan atau di latar belakang. Selain itu, Anda dapat menggunakan kelas ThreadPool untuk menjalankan kode pada utas pekerja yang dikelola oleh common language runtime.

Mulai topik

Anda memulai utas dengan menyediakan delegasi yang mewakili metode yang dijalankan utas di konstruktor kelasnya. Anda kemudian memanggil Start metode untuk memulai eksekusi.

Thread Konstruktor dapat mengambil salah satu dari dua jenis delegasi, tergantung pada apakah Anda dapat meneruskan argumen ke metode yang akan dijalankan:

• Jika metode tidak memiliki argumen, Anda meneruskan ThreadStart delegate ke konstruktor. Ini memiliki tanda tangan:

  public delegate void ThreadStart()
  

  Public Delegate Sub ThreadStart()
  

  Contoh berikut membuat dan memulai thread yang menjalankan metode ExecuteInForeground. Metode ini menampilkan informasi tentang beberapa properti utas, lalu menjalankan perulangan di mana ia menjeda selama setengah detik dan menampilkan jumlah detik yang berlalu. Ketika utas telah berjalan selama minimal lima detik, perulangan berakhir dan utas menghentikan eksekusi.

  using System;
  using System.Diagnostics;
  using System.Threading;
  
  public class Example2
  {
     public static void Main()
     {
        var th = new Thread(ExecuteInForeground);
        th.Start();
        Thread.Sleep(1000);
        Console.WriteLine($"Main thread ({Thread.CurrentThread.ManagedThreadId}) exiting...");
     }
  
     private static void ExecuteInForeground()
     {
        var sw = Stopwatch.StartNew();
        Console.WriteLine("Thread {0}: {1}, Priority {2}",
                          Thread.CurrentThread.ManagedThreadId,
                          Thread.CurrentThread.ThreadState,
                          Thread.CurrentThread.Priority);
        do {
           Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId}: Elapsed {sw.ElapsedMilliseconds / 1000.0:N2} seconds");
           Thread.Sleep(500);
        } while (sw.ElapsedMilliseconds <= 5000);
        sw.Stop();
     }
  }
  // The example displays output like the following:
  //       Thread 3: Running, Priority Normal
  //       Thread 3: Elapsed 0.00 seconds
  //       Thread 3: Elapsed 0.51 seconds
  //       Main thread (1) exiting...
  //       Thread 3: Elapsed 1.02 seconds
  //       Thread 3: Elapsed 1.53 seconds
  //       Thread 3: Elapsed 2.05 seconds
  //       Thread 3: Elapsed 2.55 seconds
  //       Thread 3: Elapsed 3.07 seconds
  //       Thread 3: Elapsed 3.57 seconds
  //       Thread 3: Elapsed 4.07 seconds
  //       Thread 3: Elapsed 4.58 seconds
  

  open System.Diagnostics
  open System.Threading
  
  let executeInForeground () =
      let sw = Stopwatch.StartNew()
  
      printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: {Thread.CurrentThread.ThreadState}, Priority {Thread.CurrentThread.Priority}"
  
      while sw.ElapsedMilliseconds <= 5000 do
          printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: Elapsed {sw.ElapsedMilliseconds / 1000L:N2} seconds"
          Thread.Sleep 500
  
      sw.Stop()
  
  let th = Thread executeInForeground
  th.Start()
  Thread.Sleep 1000
  printfn $"Main thread ({Thread.CurrentThread.ManagedThreadId}) exiting..."
  
  // The example displays output like the following:
  //       Thread 3: Running, Priority Normal
  //       Thread 3: Elapsed 0.00 seconds
  //       Thread 3: Elapsed 0.51 seconds
  //       Main thread (1) exiting...
  //       Thread 3: Elapsed 1.02 seconds
  //       Thread 3: Elapsed 1.53 seconds
  //       Thread 3: Elapsed 2.05 seconds
  //       Thread 3: Elapsed 2.55 seconds
  //       Thread 3: Elapsed 3.07 seconds
  //       Thread 3: Elapsed 3.57 seconds
  //       Thread 3: Elapsed 4.07 seconds
  //       Thread 3: Elapsed 4.58 seconds
  

  Imports System.Diagnostics
  Imports System.Threading
  
  Module Example3
      Public Sub Main()
          Dim th As New Thread(AddressOf ExecuteInForeground)
          th.Start()
          Thread.Sleep(1000)
          Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId)
      End Sub
  
      Private Sub ExecuteInForeground()
          Dim start As DateTime = DateTime.Now
          Dim sw As Stopwatch = Stopwatch.StartNew()
          Console.WriteLine("Thread {0}: {1}, Priority {2}",
                          Thread.CurrentThread.ManagedThreadId,
                          Thread.CurrentThread.ThreadState,
                          Thread.CurrentThread.Priority)
          Do
              Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds",
                             Thread.CurrentThread.ManagedThreadId,
                             sw.ElapsedMilliseconds / 1000)
              Thread.Sleep(500)
          Loop While sw.ElapsedMilliseconds <= 5000
          sw.Stop()
      End Sub
  End Module
  ' The example displays output like the following:
  '       Thread 3: Running, Priority Normal
  '       Thread 3: Elapsed 0.00 seconds
  '       Thread 3: Elapsed 0.51 seconds
  '       Main thread (1) exiting...
  '       Thread 3: Elapsed 1.02 seconds
  '       Thread 3: Elapsed 1.53 seconds
  '       Thread 3: Elapsed 2.05 seconds
  '       Thread 3: Elapsed 2.55 seconds
  '       Thread 3: Elapsed 3.07 seconds
  '       Thread 3: Elapsed 3.57 seconds
  '       Thread 3: Elapsed 4.07 seconds
  '       Thread 3: Elapsed 4.58 seconds
  

• Jika metode memiliki argumen, Anda meneruskan delegate ParameterizedThreadStart ke konstruktor. Ini memiliki tanda tangan:

  public delegate void ParameterizedThreadStart(object obj)
  

  Public Delegate Sub ParameterizedThreadStart(obj As Object)
  

  Metode yang dijalankan oleh delegasi kemudian dapat mentransmisikan (dalam C#) atau mengonversi (di Visual Basic) parameter ke jenis yang sesuai.

  Contoh berikut identik dengan yang sebelumnya, kecuali contoh ini memanggil konstruktor Thread(ParameterizedThreadStart). Versi ExecuteInForeground metode ini memiliki parameter tunggal yang mewakili perkiraan jumlah milidetik perulangan yang akan dijalankan.

  using System;
  using System.Diagnostics;
  using System.Threading;
  
  public class Example3
  {
     public static void Main()
     {
        var th = new Thread(ExecuteInForeground);
        th.Start(4500);
        Thread.Sleep(1000);
        Console.WriteLine($"Main thread ({Thread.CurrentThread.ManagedThreadId}) exiting...");
     }
  
     private static void ExecuteInForeground(Object obj)
     {
        int interval;
        try {
           interval = (int) obj;
        }
        catch (InvalidCastException) {
           interval = 5000;
        }
        var sw = Stopwatch.StartNew();
        Console.WriteLine("Thread {0}: {1}, Priority {2}",
                          Thread.CurrentThread.ManagedThreadId,
                          Thread.CurrentThread.ThreadState,
                          Thread.CurrentThread.Priority);
        do {
           Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId}: Elapsed {sw.ElapsedMilliseconds / 1000.0:N2} seconds");
           Thread.Sleep(500);
        } while (sw.ElapsedMilliseconds <= interval);
        sw.Stop();
     }
  }
  // The example displays output like the following:
  //       Thread 3: Running, Priority Normal
  //       Thread 3: Elapsed 0.00 seconds
  //       Thread 3: Elapsed 0.52 seconds
  //       Main thread (1) exiting...
  //       Thread 3: Elapsed 1.03 seconds
  //       Thread 3: Elapsed 1.55 seconds
  //       Thread 3: Elapsed 2.06 seconds
  //       Thread 3: Elapsed 2.58 seconds
  //       Thread 3: Elapsed 3.09 seconds
  //       Thread 3: Elapsed 3.61 seconds
  //       Thread 3: Elapsed 4.12 seconds
  

  open System
  open System.Diagnostics
  open System.Threading
  
  let executeInForeground obj =
      let interval =
          try
              unbox<int> obj
          with :? InvalidCastException ->
              5000
  
      let sw = Stopwatch.StartNew()
  
      printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: {Thread.CurrentThread.ThreadState}, Priority {Thread.CurrentThread.Priority}"
  
      while sw.ElapsedMilliseconds <= interval do
          printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: Elapsed {sw.ElapsedMilliseconds / 1000L:N2} seconds"
          Thread.Sleep 500
  
      sw.Stop()
  
  let th = Thread(ParameterizedThreadStart executeInForeground)
  th.Start 4500
  Thread.Sleep 1000
  printfn $"Main thread ({Thread.CurrentThread.ManagedThreadId}) exiting..."
  
  // The example displays output like the following:
  //       Thread 3: Running, Priority Normal
  //       Thread 3: Elapsed 0.00 seconds
  //       Thread 3: Elapsed 0.52 seconds
  //       Main thread (1) exiting...
  //       Thread 3: Elapsed 1.03 seconds
  //       Thread 3: Elapsed 1.55 seconds
  //       Thread 3: Elapsed 2.06 seconds
  //       Thread 3: Elapsed 2.58 seconds
  //       Thread 3: Elapsed 3.09 seconds
  //       Thread 3: Elapsed 3.61 seconds
  //       Thread 3: Elapsed 4.12 seconds
  

  Imports System.Diagnostics
  Imports System.Threading
  
  Module Example4
      Public Sub Main()
          Dim th As New Thread(AddressOf ExecuteInForeground)
          th.Start(4500)
          Thread.Sleep(1000)
          Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId)
      End Sub
  
      Private Sub ExecuteInForeground(obj As Object)
          Dim interval As Integer
          If IsNumeric(obj) Then
              interval = CInt(obj)
          Else
              interval = 5000
          End If
          Dim start As DateTime = DateTime.Now
          Dim sw As Stopwatch = Stopwatch.StartNew()
          Console.WriteLine("Thread {0}: {1}, Priority {2}",
                          Thread.CurrentThread.ManagedThreadId,
                          Thread.CurrentThread.ThreadState,
                          Thread.CurrentThread.Priority)
          Do
              Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds",
                             Thread.CurrentThread.ManagedThreadId,
                             sw.ElapsedMilliseconds / 1000)
              Thread.Sleep(500)
          Loop While sw.ElapsedMilliseconds <= interval
          sw.Stop()
      End Sub
  End Module
  ' The example displays output like the following:
  '       Thread 3: Running, Priority Normal
  '       Thread 3: Elapsed 0.00 seconds
  '       Thread 3: Elapsed 0.52 seconds
  '       Main thread (1) exiting...
  '       Thread 3: Elapsed 1.03 seconds
  '       Thread 3: Elapsed 1.55 seconds
  '       Thread 3: Elapsed 2.06 seconds
  '       Thread 3: Elapsed 2.58 seconds
  '       Thread 3: Elapsed 3.09 seconds
  '       Thread 3: Elapsed 3.61 seconds
  '       Thread 3: Elapsed 4.12 seconds
  

Anda tidak perlu menyimpan referensi ke Thread objek setelah Anda memulai utas. Utas terus dijalankan hingga prosedur utas selesai.

Mengambil objek Utas

Anda dapat menggunakan properti statis (Shared di Visual Basic) CurrentThread untuk mengambil referensi ke utas yang sedang dijalankan dari kode yang sedang dieksekusi oleh utas tersebut. Contoh berikut menggunakan properti CurrentThread untuk menampilkan informasi tentang utas aplikasi utama, utas latar depan lainnya, utas latar belakang, dan utas kumpulan utas.

using System;
using System.Threading;

public class Example1
{
   static Object obj = new Object();
   
   public static void Main()
   {
      ThreadPool.QueueUserWorkItem(ShowThreadInformation);
      var th1 = new Thread(ShowThreadInformation);
      th1.Start();
      var th2 = new Thread(ShowThreadInformation);
      th2.IsBackground = true;
      th2.Start();
      Thread.Sleep(500);
      ShowThreadInformation(null); 
   }
   
   private static void ShowThreadInformation(Object state)
   {
      lock (obj) {
         var th  = Thread.CurrentThread;
         Console.WriteLine($"Managed thread #{th.ManagedThreadId}: ");
         Console.WriteLine($"   Background thread: {th.IsBackground}");
         Console.WriteLine($"   Thread pool thread: {th.IsThreadPoolThread}");
         Console.WriteLine($"   Priority: {th.Priority}");
         Console.WriteLine($"   Culture: {th.CurrentCulture.Name}");
         Console.WriteLine($"   UI culture: {th.CurrentUICulture.Name}");
         Console.WriteLine();
      }   
   }
}
// The example displays output like the following:
//       Managed thread #6:
//          Background thread: True
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//       
//       Managed thread #3:
//          Background thread: True
//          Thread pool thread: True
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//       
//       Managed thread #4:
//          Background thread: False
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//       
//       Managed thread #1:
//          Background thread: False
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US

open System.Threading

let obj = obj ()

let showThreadInformation (state: obj) =
    lock obj (fun () ->
        let th = Thread.CurrentThread
        printfn $"Managed thread #{th.ManagedThreadId}: "
        printfn $"   Background thread: {th.IsBackground}"
        printfn $"   Thread pool thread: {th.IsThreadPoolThread}"
        printfn $"   Priority: {th.Priority}"
        printfn $"   Culture: {th.CurrentCulture.Name}"
        printfn $"   UI culture: {th.CurrentUICulture.Name}"
        printfn "")

ThreadPool.QueueUserWorkItem showThreadInformation |> ignore
let th1 = Thread(ParameterizedThreadStart showThreadInformation)
th1.Start()
let th2 = Thread(ParameterizedThreadStart showThreadInformation)
th2.IsBackground <- true
th2.Start()
Thread.Sleep 500
showThreadInformation ()

// The example displays output like the following:
//       Managed thread #6:
//          Background thread: True
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//
//       Managed thread #3:
//          Background thread: True
//          Thread pool thread: True
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//
//       Managed thread #4:
//          Background thread: False
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US
//
//       Managed thread #1:
//          Background thread: False
//          Thread pool thread: False
//          Priority: Normal
//          Culture: en-US
//          UI culture: en-US

Imports System.Threading

Module Example2
    Private lock As New Object()

    Public Sub Main()
        ThreadPool.QueueUserWorkItem(AddressOf ShowThreadInformation)
        Dim th1 As New Thread(AddressOf ShowThreadInformation)
        th1.Start()
        Dim th2 As New Thread(AddressOf ShowThreadInformation)
        th2.IsBackground = True
        th2.Start()
        Thread.Sleep(500)
        ShowThreadInformation(Nothing)
    End Sub

    Private Sub ShowThreadInformation(state As Object)
        SyncLock lock
            Dim th As Thread = Thread.CurrentThread
            Console.WriteLine("Managed thread #{0}: ", th.ManagedThreadId)
            Console.WriteLine("   Background thread: {0}", th.IsBackground)
            Console.WriteLine("   Thread pool thread: {0}", th.IsThreadPoolThread)
            Console.WriteLine("   Priority: {0}", th.Priority)
            Console.WriteLine("   Culture: {0}", th.CurrentCulture.Name)
            Console.WriteLine("   UI culture: {0}", th.CurrentUICulture.Name)
            Console.WriteLine()
        End SyncLock
    End Sub
End Module
' The example displays output like the following:
'       ' Managed thread #6:
'          Background thread: True
'          Thread pool thread: False
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US
'       
'       Managed thread #3:
'          Background thread: True
'          Thread pool thread: True
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US
'       
'       Managed thread #4:
'          Background thread: False
'          Thread pool thread: False
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US
'       
'       Managed thread #1:
'          Background thread: False
'          Thread pool thread: False
'          Priority: Normal
'          Culture: en-US
'          UI culture: en-US

Thread latar depan dan latar belakang

Instans Thread kelas mewakili utas latar depan atau utas latar belakang. Utas latar belakang identik dengan utas latar depan dengan satu pengecualian: utas latar belakang tidak menjaga proses tetap berjalan jika semua utas latar depan telah dihentikan. Setelah semua utas latar depan dihentikan, runtime menghentikan semua utas latar belakang dan mematikannya.

Secara default, utas berikut dijalankan di latar depan:

• Utas aplikasi utama.

• Semua utas yang dibuat dengan memanggil Thread konstruktor kelas.

Utas berikut dijalankan di latar belakang secara default:

• Utas kumpulan utas, yang berasal dari kumpulan utas pekerja yang dikelola oleh runtime. Anda dapat mengonfigurasi kumpulan utas dan menjadwalkan tugas pada utas dalam kumpulan tersebut dengan menggunakan kelas ThreadPool .

  Nota

  Operasi asinkron berbasis tugas secara otomatis dijalankan pada utas kumpulan utas. Operasi asinkron berbasis tugas menggunakan Task kelas dan Task<TResult> untuk mengimplementasikan pola asinkron berbasis tugas.

• Semua utas yang memasuki lingkungan eksekusi terkelola dari kode yang tidak dikelola.

Anda dapat mengubah utas untuk dijalankan di latar belakang dengan mengatur IsBackground properti kapan saja. Utas latar belakang berguna untuk operasi apa pun yang harus dilanjutkan selama aplikasi berjalan tetapi tidak boleh mencegah aplikasi berhenti, seperti memantau perubahan sistem file atau koneksi soket masuk.

Contoh berikut menggambarkan perbedaan antara thread latar depan dan latar belakang. Ini mirip dengan contoh pertama di bagian Mulai utas, kecuali bahwa utas tersebut diatur untuk dijalankan secara latar belakang sebelum memulainya. Seperti yang ditunjukkan oleh output, perulangan terganggu sebelum dijalankan selama lima detik.

using System;
using System.Diagnostics;
using System.Threading;

public class Example
{
   public static void Main()
   {
      var th = new Thread(ExecuteInForeground);
      th.IsBackground = true;
      th.Start();
      Thread.Sleep(1000);
      Console.WriteLine($"Main thread ({Thread.CurrentThread.ManagedThreadId}) exiting...");
   }

   private static void ExecuteInForeground()
   {
      var sw = Stopwatch.StartNew();
      Console.WriteLine("Thread {0}: {1}, Priority {2}",
                        Thread.CurrentThread.ManagedThreadId,
                        Thread.CurrentThread.ThreadState,
                        Thread.CurrentThread.Priority);
      do {
         Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId}: Elapsed {sw.ElapsedMilliseconds / 1000.0:N2} seconds");
         Thread.Sleep(500);
      } while (sw.ElapsedMilliseconds <= 5000);
      sw.Stop();
   }
}
// The example displays output like the following:
//       Thread 3: Background, Priority Normal
//       Thread 3: Elapsed 0.00 seconds
//       Thread 3: Elapsed 0.51 seconds
//       Main thread (1) exiting...

open System.Diagnostics
open System.Threading

let executeInForeground () =
    let sw = Stopwatch.StartNew()
    printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: {Thread.CurrentThread.ThreadState}, Priority {Thread.CurrentThread.Priority}"
    while sw.ElapsedMilliseconds <= 5000 do
        printfn $"Thread {Thread.CurrentThread.ManagedThreadId}: Elapsed {sw.ElapsedMilliseconds / 1000L:N2} seconds"
        Thread.Sleep 500
    sw.Stop()

let th = Thread executeInForeground
th.IsBackground <- true
th.Start()
Thread.Sleep 1000
printfn $"Main thread ({Thread.CurrentThread.ManagedThreadId}) exiting..."

// The example displays output like the following:
//       Thread 3: Background, Priority Normal
//       Thread 3: Elapsed 0.00 seconds
//       Thread 3: Elapsed 0.51 seconds
//       Main thread (1) exiting...

Imports System.Diagnostics
Imports System.Threading

Module Example1
    Public Sub Main()
        Dim th As New Thread(AddressOf ExecuteInForeground)
        th.IsBackground = True
        th.Start()
        Thread.Sleep(1000)
        Console.WriteLine("Main thread ({0}) exiting...", Thread.CurrentThread.ManagedThreadId)
    End Sub

    Private Sub ExecuteInForeground()
        Dim start As DateTime = DateTime.Now
        Dim sw As Stopwatch = Stopwatch.StartNew()
        Console.WriteLine("Thread {0}: {1}, Priority {2}",
                        Thread.CurrentThread.ManagedThreadId,
                        Thread.CurrentThread.ThreadState,
                        Thread.CurrentThread.Priority)
        Do
            Console.WriteLine("Thread {0}: Elapsed {1:N2} seconds",
                           Thread.CurrentThread.ManagedThreadId,
                           sw.ElapsedMilliseconds / 1000)
            Thread.Sleep(500)
        Loop While sw.ElapsedMilliseconds <= 5000
        sw.Stop()
    End Sub
End Module
' The example displays output like the following:
'       Thread 3: Background, Priority Normal
'       Thread 3: Elapsed 0.00 seconds
'       Thread 3: Elapsed 0.51 seconds
'       Main thread (1) exiting...

Budaya dan jalinan

Setiap utas memiliki budaya, yang diwakili oleh properti CurrentCulture, dan budaya UI, yang diwakili oleh properti CurrentUICulture. Kebudayaan saat ini mendukung operasi yang peka budaya, seperti pemrosesan dan pemformatan, perbandingan string, dan pengurutan, serta mengontrol sistem penulisan dan kalender yang digunakan oleh benang. Budaya UI saat ini menyediakan pengambilan sumber daya yang sensitif terhadap budaya dalam file sumber daya.

Penting

Properti CurrentCulture dan CurrentUICulture tidak berfungsi dengan andal saat digunakan dengan utas apa pun selain utas saat ini. Dalam .NET Framework, membaca properti ini dapat diandalkan, meskipun mengatur properti ini untuk utas selain utas saat ini tidak dapat diandalkan. Pada .NET Core, sebuah InvalidOperationException akan dilemparkan jika sebuah utas mencoba membaca atau menulis properti ini dari utas yang berbeda. Kami menyarankan agar Anda menggunakan properti CultureInfo.CurrentCulture dan CultureInfo.CurrentUICulture untuk mengambil dan mengatur budaya saat ini.

Ketika sebuah utas baru dibuat, budaya dan budaya UI-nya ditentukan oleh budaya sistem dan budaya UI saat ini, bukan oleh budaya dan budaya UI dari utas asal tempat utas baru tersebut dibuat. Ini berarti, misalnya, bahwa jika budaya sistem saat ini adalah Bahasa Inggris (Amerika Serikat) dan budaya utas aplikasi utama saat ini adalah Prancis (Prancis), budaya utas baru yang dibuat dengan memanggil Thread(ParameterizedThreadStart) konstruktor dari utas utama adalah Inggris (Amerika Serikat), dan bukan Prancis (Prancis). Untuk informasi selengkapnya, lihat bagian "Budaya dan Utas" dari topik CultureInfo kelas.

Penting

Hal ini tidak berlaku untuk utas yang menjalankan operasi asinkron pada aplikasi yang menargetkan .NET Framework 4.6 dan versi lebih baru. Dalam hal ini, budaya dan budaya UI adalah bagian dari konteks operasi asinkron; utas tempat operasi asinkron dijalankan secara default mewarisi budaya dan budaya UI utas tempat operasi asinkron diluncurkan. Untuk informasi selengkapnya, lihat bagian "Budaya dan operasi asinkron berbasis tugas" dari CultureInfo keterangan kelas.

Anda dapat melakukan salah satu langkah berikut untuk memastikan bahwa semua utas yang dijalankan dalam aplikasi memiliki kebudayaan dan kebudayaan antarmuka pengguna yang sama:

• Anda dapat meneruskan CultureInfo objek yang mewakili budaya tersebut ke ParameterizedThreadStart delegasi atau ThreadPool.QueueUserWorkItem(WaitCallback, Object) metode .

• Untuk aplikasi yang berjalan pada .NET Framework 4.5 dan versi yang lebih baru, Anda dapat menentukan budaya dan budaya UI yang akan ditetapkan ke semua utas yang dibuat di domain aplikasi dengan mengatur nilai CultureInfo.DefaultThreadCurrentCulture properti dan CultureInfo.DefaultThreadCurrentUICulture . Perhatikan bahwa ini adalah pengaturan domain per aplikasi.

Untuk informasi dan contoh selengkapnya, lihat bagian "Kebudayaan dan thread" dari CultureInfo catatan kelas.

Mendapatkan informasi tentang dan mengontrol utas

Anda dapat mengambil sejumlah nilai properti yang menyediakan informasi tentang utas. Dalam beberapa kasus, Anda juga dapat mengatur nilai-nilai properti ini untuk mengendalikan operasi benang. Karakteristik dari Utas Ini Meliputi:

• Sebuah nama. Name adalah atribut write-once yang dapat Anda gunakan untuk mengidentifikasi utas. Nilai defaultnya adalah null.

• Kode hash, yang dapat Anda ambil dengan memanggil GetHashCode metode . Kode hash dapat digunakan untuk mengidentifikasi utas secara unik; untuk masa pakai utas Anda, kode hashnya tidak akan bertabrakan dengan nilai dari utas lain, terlepas dari domain aplikasi tempat Anda mendapatkan nilainya.

• ID utas. Nilai properti baca-saja ManagedThreadId ditetapkan oleh runtime dan secara unik mengidentifikasi utas dalam prosesnya.

  Nota

  ThreadId sistem operasi tidak memiliki hubungan tetap dengan utas terkelola, karena host yang tidak dikelola dapat mengontrol hubungan antara utas terkelola dan tidak terkelola. Secara khusus, host canggih dapat menggunakan CLR Hosting API untuk menjadwalkan banyak utas terkelola terhadap utas sistem operasi yang sama, atau untuk memindahkan utas terkelola antara utas sistem operasi yang berbeda.

• Status utas saat ini. Selama keberadaannya, sebuah utas selalu berada dalam satu atau lebih status yang ditentukan oleh properti ThreadState.

• Tingkat prioritas penjadwalan, yang didefinisikan oleh properti ThreadPriority. Meskipun Anda dapat mengatur nilai ini untuk meminta prioritas dari suatu utas, penetapan nilai tersebut belum tentu dihormati oleh sistem operasi.

• Properti baca-saja IsThreadPoolThread , yang menunjukkan apakah utas adalah utas kumpulan utas.

• Properti IsBackground. Untuk informasi selengkapnya, lihat bagian Latar Depan dan utas latar belakang .

Contoh

Contoh berikut menunjukkan fungsionalitas utas sederhana.

using System;
using System.Threading;

// Simple threading scenario:  Start a static method running
// on a second thread.
public class ThreadExample {
    // The ThreadProc method is called when the thread starts.
    // It loops ten times, writing to the console and yielding
    // the rest of its time slice each time, and then ends.
    public static void ThreadProc() {
        for (int i = 0; i < 10; i++) {
            Console.WriteLine($"ThreadProc: {i}");
            // Yield the rest of the time slice.
            Thread.Sleep(0);
        }
    }

    public static void Main() {
        Console.WriteLine("Main thread: Start a second thread.");
        // The constructor for the Thread class requires a ThreadStart
        // delegate that represents the method to be executed on the
        // thread.  C# simplifies the creation of this delegate.
        Thread t = new Thread(new ThreadStart(ThreadProc));

        // Start ThreadProc.  Note that on a uniprocessor, the new
        // thread does not get any processor time until the main thread
        // is preempted or yields.  Uncomment the Thread.Sleep that
        // follows t.Start() to see the difference.
        t.Start();
        //Thread.Sleep(0);

        for (int i = 0; i < 4; i++) {
            Console.WriteLine("Main thread: Do some work.");
            Thread.Sleep(0);
        }

        Console.WriteLine("Main thread: Call Join(), to wait until ThreadProc ends.");
        t.Join();
        Console.WriteLine("Main thread: ThreadProc.Join has returned.  Press Enter to end program.");
        Console.ReadLine();
    }
}

open System.Threading

// Simple threading scenario:  Start a static method running
// on a second thread.

// The ThreadProc method is called when the thread starts.
// It loops ten times, writing to the console and yielding
// the rest of its time slice each time, and then ends.
let threadProc () =
    for i = 0 to 9 do
        printfn $"ThreadProc: {i}"
        // Yield the rest of the time slice.
        Thread.Sleep 0

printfn "Main thread: Start a second thread."
// The constructor for the Thread class requires a ThreadStart
// delegate that represents the method to be executed on the
// thread. F# simplifies the creation of this delegate.
let t = Thread threadProc

// Start ThreadProc.  Note that on a uniprocessor, the new
// thread does not get any processor time until the main thread
// is preempted or yields.  Uncomment the Thread.Sleep that
// follows t.Start() to see the difference.
t.Start()
//Thread.Sleep 0

for _ = 0 to 3 do
    printfn "Main thread: Do some work."
    Thread.Sleep 0

printfn "Main thread: Call Join(), to wait until ThreadProc ends."
t.Join()
printfn "Main thread: ThreadProc.Join has returned.  Press Enter to end program."
stdin.ReadLine() |> ignore

Imports System.Threading

' Simple threading scenario:  Start a Shared method running
' on a second thread.
Public Class ThreadExample
    ' The ThreadProc method is called when the thread starts.
    ' It loops ten times, writing to the console and yielding 
    ' the rest of its time slice each time, and then ends.
    Public Shared Sub ThreadProc()
        Dim i As Integer
        For i = 0 To 9
            Console.WriteLine("ThreadProc: {0}", i)
            ' Yield the rest of the time slice.
            Thread.Sleep(0)
        Next
    End Sub

    Public Shared Sub Main()
        Console.WriteLine("Main thread: Start a second thread.")
        ' The constructor for the Thread class requires a ThreadStart 
        ' delegate.  The Visual Basic AddressOf operator creates this
        ' delegate for you.
        Dim t As New Thread(AddressOf ThreadProc)

        ' Start ThreadProc.  Note that on a uniprocessor, the new 
        ' thread does not get any processor time until the main thread 
        ' is preempted or yields.  Uncomment the Thread.Sleep that 
        ' follows t.Start() to see the difference.
        t.Start()
        'Thread.Sleep(0)

        Dim i As Integer
        For i = 1 To 4
            Console.WriteLine("Main thread: Do some work.")
            Thread.Sleep(0)
        Next

        Console.WriteLine("Main thread: Call Join(), to wait until ThreadProc ends.")
        t.Join()
        Console.WriteLine("Main thread: ThreadProc.Join has returned.  Press Enter to end program.")
        Console.ReadLine()
    End Sub
End Class

Kode ini menghasilkan output yang mirip dengan yang berikut:

[VB, C++, C#]
Main thread: Start a second thread.
Main thread: Do some work.
ThreadProc: 0
Main thread: Do some work.
ThreadProc: 1
Main thread: Do some work.
ThreadProc: 2
Main thread: Do some work.
ThreadProc: 3
Main thread: Call Join(), to wait until ThreadProc ends.
ThreadProc: 4
ThreadProc: 5
ThreadProc: 6
ThreadProc: 7
ThreadProc: 8
ThreadProc: 9
Main thread: ThreadProc.Join has returned. Press Enter to end program.