System.Threading.Thread 클래스

아티클
01/10/2024

이 문서에서는 이 API에 대한 참조 설명서에 대한 추가 설명서를 제공합니다.

클래스는 Thread 스레드를 만들고 제어하며 우선 순위를 설정하고 상태 가져옵니다.

프로세스가 시작 되 면 공용 언어 런타임 애플리케이션 코드를 실행 하는 단일 포그라운드 스레드를 자동으로 만듭니다. 이 기본 포그라운드 스레드와 함께 프로세스는 프로세스와 연결된 프로그램 코드의 일부를 실행하는 하나 이상의 스레드를 만들 수 있습니다. 이러한 스레드는 포그라운드 또는 백그라운드에서 실행할 수 있습니다. 또한 클래스를 ThreadPool 사용하여 공용 언어 런타임에서 관리되는 작업자 스레드에서 코드를 실행할 수 있습니다.

스레드 시작

스레드가 클래스 생성자에서 실행할 메서드를 나타내는 대리자를 제공하여 스레드를 시작합니다. 그런 다음, 메서드를 Start 호출하여 실행을 시작합니다.

Thread 생성자는 실행할 메서드에 인수를 전달할 수 있는지 여부에 따라 두 대리자 형식 중 하나를 사용할 수 있습니다.

메서드에 인수가 없는 경우 생성자에 대리자를 전달 ThreadStart 합니다. 서명이 있습니다.

public delegate void ThreadStart()

Public Delegate Sub ThreadStart()

다음 예제에서는 메서드를 실행하는 스레드를 만들고 시작합니다 ExecuteInForeground . 메서드는 일부 스레드 속성에 대한 정보를 표시한 다음, 루프를 실행하여 1초 반 동안 일시 중지하고 경과된 시간(초)을 표시합니다. 스레드가 5초 이상 실행되면 루프가 종료되고 스레드가 실행을 종료합니다.

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 ({0}) exiting...",
                        Thread.CurrentThread.ManagedThreadId);
   }

   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 {0}: Elapsed {1:N2} seconds",
                           Thread.CurrentThread.ManagedThreadId,
                           sw.ElapsedMilliseconds / 1000.0);
         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

메서드에 인수가 있는 경우 생성자에 대리자를 전달 ParameterizedThreadStart 합니다. 서명이 있습니다.

public delegate void ParameterizedThreadStart(object obj)

Public Delegate Sub ParameterizedThreadStart(obj As Object)

대리자가 실행하는 메서드는 C#으로 캐스팅하거나(Visual Basic에서) 매개 변수를 적절한 형식으로 변환할 수 있습니다.

다음 예제는 생성자를 호출한다는 점을 제외하고 이전 예제와 Thread(ParameterizedThreadStart) 동일합니다. 이 버전의 ExecuteInForeground 메서드에는 루프가 실행될 대략적인 시간(밀리초)을 나타내는 단일 매개 변수가 있습니다.

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 ({0}) exiting...",
                        Thread.CurrentThread.ManagedThreadId);
   }

   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 {0}: Elapsed {1:N2} seconds",
                           Thread.CurrentThread.ManagedThreadId,
                           sw.ElapsedMilliseconds / 1000.0);
         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

스레드를 시작한 후에는 개체에 대한 참조를 Thread 유지할 필요가 없습니다. 스레드 프로시저가 완료될 때까지 스레드는 계속 실행됩니다.

스레드 개체 검색

정적(Shared Visual Basic의 경우) CurrentThread 속성을 사용하여 스레드가 실행 중인 코드에서 현재 실행 중인 스레드에 대한 참조를 검색할 수 있습니다. 다음 예제에서는 CurrentThread 속성을 기본 애플리케이션 스레드, 다른 포그라운드 스레드, 백그라운드 스레드 및 스레드 풀 스레드에 대 한 정보를 표시 합니다.

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 #{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();
      }   
   }
}
// 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 인스턴스는 포그라운드 스레드 또는 백그라운드 스레드를 나타냅니다. 백그라운드 스레드는 한 가지 예외를 제외하고 포그라운드 스레드와 동일합니다. 백그라운드 스레드는 모든 포그라운드 스레드가 종료된 경우 프로세스를 계속 실행하지 않습니다. 모든 포그라운드 스레드가 중지되면 런타임은 모든 백그라운드 스레드를 중지하고 종료합니다.

기본적으로 다음 스레드는 포그라운드에서 실행됩니다.

기본 애플리케이션 스레드입니다.
클래스 생성자를 호출 Thread 하여 만든 모든 스레드입니다.

다음 스레드는 기본적으로 백그라운드에서 실행됩니다.

작업자 스레드 풀에서 제공되는 스레드 풀 스레드는 런타임에 의해 기본. 클래스를 사용하여 스레드 풀을 구성하고 스레드 풀 스레드에서 작업을 예약할 ThreadPool 수 있습니다.

참고 항목

작업 기반 비동기 작업은 스레드 풀 스레드에서 자동으로 실행됩니다. 작업 기반 비동기 작업은 및 Task<TResult> 클래스를 사용하여 Task 작업 기반 비동기 패턴을 구현합니다.
관리되지 않는 코드에서 관리되는 실행 환경을 입력하는 모든 스레드입니다.

언제든지 속성을 설정하여 백그라운드에서 실행되도록 스레드를 IsBackground 변경할 수 있습니다. 백그라운드 스레드는 애플리케이션이 실행 되 고 있지만 종료 파일 시스템 변경 사항 또는 들어오는 소켓 연결을 모니터링 하는 등의 애플리케이션을 중지 되지는 않습니다 있다면 계속 해야 하는 모든 작업에 유용 합니다.

다음 예제에서는 포그라운드 스레드와 백그라운드 스레드의 차이점을 보여 줍니다. 스레드 시작 섹션의 첫 번째 예제와 유사합니다. 단, 스레드를 시작하기 전에 백그라운드에서 실행되도록 설정하는 것입니다. 출력에서 보여 주듯이 루프는 5초 동안 실행되기 전에 중단됩니다.

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 ({0}) exiting...",
                        Thread.CurrentThread.ManagedThreadId);
   }

   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 {0}: Elapsed {1:N2} seconds",
                           Thread.CurrentThread.ManagedThreadId,
                           sw.ElapsedMilliseconds / 1000.0);
         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...

문화권 및 스레드

각 스레드에는 속성으로 표현되는 CurrentCulture 문화권과 속성이 나타내는 UI 문화권이 있습니다 CurrentUICulture . 현재 문화권은 구문 분석 및 서식 지정, 문자열 비교 및 정렬과 같은 문화권에 민감한 작업을 지원하고 스레드에서 사용하는 쓰기 시스템과 달력을 제어합니다. 현재 UI 문화권은 리소스 파일의 리소스에 대한 문화권 구분 검색을 제공합니다.

Important

CurrentCulture 현재 스레드가 아닌 다른 스레드와 함께 사용하면 속성과 CurrentUICulture 속성이 안정적으로 작동하지 않습니다. .NET Framework에서 이러한 속성을 읽는 것은 신뢰할 수 있지만 현재 스레드가 아닌 스레드에 대해 이러한 속성을 설정하지는 않습니다. .NET Core에서 InvalidOperationException 스레드가 다른 스레드에서 이러한 속성을 읽거나 쓰려고 하면 throw됩니다. 현재 문화권을 CultureInfo.CurrentCulture 검색하고 설정하려면 해당 및 CultureInfo.CurrentUICulture 속성을 사용하는 것이 좋습니다.

새 스레드가 인스턴스화되면 해당 문화권 및 UI 문화권은 새 스레드가 만들어진 스레드의 문화권 및 UI 문화권이 아니라 현재 시스템 문화권 및 UI 문화권에 의해 정의됩니다. 예를 들어 현재 시스템 문화권이 영어(미국)이고 기본 애플리케이션 스레드의 현재 문화권이 프랑스어(프랑스)인 경우 기본 스레드에서 생성자를 호출 Thread(ParameterizedThreadStart) 하여 만든 새 스레드의 문화권은 프랑스어(프랑스)가 아닌 영어(미국)입니다. 자세한 내용은 클래스 항목의 "문화권 및 스레드" 섹션을 CultureInfo 참조하세요.

Important

.NET Framework 4.6 이상 버전을 대상으로 하는 앱에 대해 비동기 작업을 실행하는 스레드의 경우는 그렇지 않습니다. 이 경우 문화권 및 UI 문화권은 비동기 작업의 컨텍스트에 속합니다. 기본적으로 비동기 작업이 실행되는 스레드는 비동기 작업이 시작된 스레드의 문화권 및 UI 문화권을 상속합니다. 자세한 내용은 클래스 설명의 "문화권 및 작업 기반 비동기 작업" 섹션을 CultureInfo 참조하세요.

하나를 수행 하면 동일한 문화권 및 UI 문화권 공유 애플리케이션에서 실행 중의 모든 스레드가 되도록 합니다.

해당 문화권을 나타내는 개체를 CultureInfo 대리자 또는 메서드에 ParameterizedThreadStart ThreadPool.QueueUserWorkItem(WaitCallback, Object) 전달할 수 있습니다.
.NET Framework 4.5 이상 버전에서 실행되는 앱의 경우 애플리케이션에서 만든 모든 스레드에 할당할 문화권 및 UI 문화권을 정의할 수 있습니다기본 및 속성의 CultureInfo.DefaultThreadCurrentCulture CultureInfo.DefaultThreadCurrentUICulture 값을 설정합니다. 애플리케이션별 do기본 설정입니다.

자세한 내용 및 예제는 클래스 설명의 "문화권 및 스레드" 섹션을 CultureInfo 참조하세요.

스레드에 대한 정보 가져오기 및 제어

스레드에 대한 정보를 제공하는 여러 속성 값을 검색할 수 있습니다. 경우에 따라 이러한 속성 값을 설정하여 스레드의 작업을 제어할 수도 있습니다. 이러한 스레드 속성은 다음과 같습니다.

이름 Name 는 스레드를 식별하는 데 사용할 수 있는 쓰기-한 번 속성입니다. 기본값은 .입니다 null.
메서드를 호출하여 검색할 수 있는 해시 코드입니다 GetHashCode . 스레드를 고유 하 게 식별 하려면 해시 코드를 사용할 수 있습니다. 스레드 수명 동안 해당 해시 코드 값을 가져온 애플리케이션 도메인에 관계 없이 다른 스레드에서 값과 충돌 하지 않습니다.
스레드 ID입니다. 읽기 전용 ManagedThreadId 속성의 값은 런타임에서 할당되며 프로세스 내에서 스레드를 고유하게 식별합니다.

참고 항목

관리되지 않는 호스트가 관리되는 스레드와 관리되지 않는 스레드 간의 관계를 제어할 수 있으므로 운영 체제 ThreadId 는 관리되는 스레드에 대한 고정 관계를 포함하지 않습니다. 특히 정교한 호스트는 CLR 호스팅 API를 사용하여 동일한 운영 체제 스레드에 대해 많은 관리되는 스레드를 예약하거나 다른 운영 체제 스레드 간에 관리되는 스레드를 이동할 수 있습니다.
스레드의 현재 상태입니다. 스레드가 존재하는 동안에는 항상 속성에서 정의한 상태 중 하나 이상에 있습니다 ThreadState .
속성에 의해 ThreadPriority 정의된 예약 우선 순위 수준입니다. 스레드의 우선 순위를 요청하도록 이 값을 설정할 수 있지만 운영 체제에서 적용할 수 있는 것은 아닙니다.
스레드가 스레드 풀 스레드인지 여부를 나타내는 읽기 전용 IsThreadPoolThread 속성입니다.
IsBackground 속성 자세한 내용은 포그라운드 및 백그라운드 스레드 섹션을 참조 하세요 .

예제

다음 예제에서는 간단한 스레딩 기능을 보여 줍니다.

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: {0}", 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

이 코드는 다음과 유사한 출력을 생성합니다.

[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.