Thread.AllocateNamedDataSlot(String) 메서드

정의

네임스페이스:: System.Threading

어셈블리:: netstandard.dll, System.Threading.Thread.dll

어셈블리:: System.Threading.Thread.dll

어셈블리:: mscorlib.dll

어셈블리:: netstandard.dll

Source:: Thread.cs

Source:: Thread.cs

Source:: Thread.cs

Source:: Thread.cs

Source:: Thread.cs

중요

일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.

모든 스레드에 명명된 데이터 슬롯을 할당합니다. 성능을 향상시키려면 특성으로 ThreadStaticAttribute 표시된 필드를 대신 사용합니다.

public:
 static LocalDataStoreSlot ^ AllocateNamedDataSlot(System::String ^ name);

public static LocalDataStoreSlot AllocateNamedDataSlot(string name);

static member AllocateNamedDataSlot : string -> LocalDataStoreSlot

Public Shared Function AllocateNamedDataSlot (name As String) As LocalDataStoreSlot

매개 변수

name: String

할당할 데이터 슬롯의 이름입니다.

반품

LocalDataStoreSlot

모든 스레드에서 할당된 명명된 데이터 슬롯입니다.

예외

ArgumentException

지정된 이름의 명명된 데이터 슬롯이 이미 있습니다.

예제

이 섹션에는 두 가지 코드 예제가 포함되어 있습니다. 첫 번째 예제에서는 특성으로 ThreadStaticAttribute 표시된 필드를 사용하여 스레드 관련 정보를 보유하는 방법을 보여줍니다. 두 번째 예제에서는 데이터 슬롯을 사용하여 동일한 작업을 수행하는 방법을 보여줍니다.

첫 번째 예제

다음 예제에서는 표시된 필드를 사용하여 스레드 관련 정보를 보유하는 방법을 보여 주는 예제입니다 ThreadStaticAttribute . 이 기술은 두 번째 예제에 표시된 기술보다 더 나은 성능을 제공합니다.

using System;
using System.Threading;

class Test
{
    static void Main()
    {
        for(int i = 0; i < 3; i++)
        {
            Thread newThread = new Thread(ThreadData.ThreadStaticDemo);
            newThread.Start();
        }
    }
}

class ThreadData
{
    [ThreadStatic]
    static int threadSpecificData;

    public static void ThreadStaticDemo()
    {
        // Store the managed thread id for each thread in the static
        // variable.
        threadSpecificData = Thread.CurrentThread.ManagedThreadId;
      
        // Allow other threads time to execute the same code, to show
        // that the static data is unique to each thread.
        Thread.Sleep( 1000 );

        // Display the static data.
        Console.WriteLine( "Data for managed thread {0}: {1}", 
            Thread.CurrentThread.ManagedThreadId, threadSpecificData );
    }
}

/* This code example produces output similar to the following:

Data for managed thread 4: 4
Data for managed thread 5: 5
Data for managed thread 3: 3
 */

open System
open System.Threading

type ThreadData() =
    // Create a static variable to hold the data for each thread.
    [<ThreadStatic; DefaultValue>]
    static val mutable private threadSpecificData : int

    static member ThreadStaticDemo() =
        // Store the managed thread id for each thread in the static
        // variable.
        ThreadData.threadSpecificData <- Thread.CurrentThread.ManagedThreadId
        
        // Allow other threads time to execute the same code, to show
        // that the static data is unique to each thread.
        Thread.Sleep 1000

        // Display the static data.
        printfn $"Data for managed thread {Thread.CurrentThread.ManagedThreadId}: {ThreadData.threadSpecificData}" 

for i = 0 to 2 do 
    let newThread = Thread ThreadData.ThreadStaticDemo
    newThread.Start()

// This code example produces output similar to the following:
//       Data for managed thread 4: 4
//       Data for managed thread 5: 5
//       Data for managed thread 3: 3

Imports System.Threading

Class Test

    <MTAThread> _
    Shared Sub Main()

        For i As Integer = 1 To 3
            Dim newThread As New Thread(AddressOf ThreadData.ThreadStaticDemo)
            newThread.Start()
        Next i

    End Sub

End Class

Class ThreadData

    <ThreadStatic> _
    Shared threadSpecificData As Integer

    Shared Sub ThreadStaticDemo()

        ' Store the managed thread id for each thread in the static
        ' variable.
        threadSpecificData = Thread.CurrentThread.ManagedThreadId
      
        ' Allow other threads time to execute the same code, to show
        ' that the static data is unique to each thread.
        Thread.Sleep( 1000 )

        ' Display the static data.
        Console.WriteLine( "Data for managed thread {0}: {1}", _
            Thread.CurrentThread.ManagedThreadId, threadSpecificData )

    End Sub

End Class

' This code example produces output similar to the following:
'
'Data for managed thread 4: 4
'Data for managed thread 5: 5
'Data for managed thread 3: 3

두 번째 예제

다음 예제에서는 명명된 데이터 슬롯을 사용하여 스레드 관련 정보를 저장하는 방법을 보여 줍니다.

메모

메서드가 아직 할당되지 않은 경우 슬롯을 AllocateNamedDataSlot 할당하기 때문에 예제 코드는 메서드를 사용하지 GetNamedDataSlot 않습니다. 메서드를 AllocateNamedDataSlot 사용하는 경우 프로그램 시작 시 주 스레드에서 호출해야 합니다.

using System;
using System.Threading;

class Test
{
    public static void Main()
    {
        Thread[] newThreads = new Thread[4];
        int i;
        for (i = 0; i < newThreads.Length; i++)
        {
            newThreads[i] =
                new Thread(new ThreadStart(Slot.SlotTest));
            newThreads[i].Start();
        }
        Thread.Sleep(2000);
        for (i = 0; i < newThreads.Length; i++)
        {
            newThreads[i].Join();
            Console.WriteLine("Thread_{0} finished.",
                newThreads[i].ManagedThreadId);
        }
    }
}

class Slot
{
    private static Random randomGenerator = new Random();

    public static void SlotTest()
    {
        // Set random data in each thread's data slot.
        int slotData = randomGenerator.Next(1, 200);
        int threadId = Thread.CurrentThread.ManagedThreadId;

        Thread.SetData(
            Thread.GetNamedDataSlot("Random"),
            slotData);

        // Show what was saved in the thread's data slot.
        Console.WriteLine("Data stored in thread_{0}'s data slot: {1,3}",
            threadId, slotData);

        // Allow other threads time to execute SetData to show
        // that a thread's data slot is unique to itself.
        Thread.Sleep(1000);

        int newSlotData =
            (int)Thread.GetData(Thread.GetNamedDataSlot("Random"));

        if (newSlotData == slotData)
        {
            Console.WriteLine("Data in thread_{0}'s data slot is still: {1,3}",
                threadId, newSlotData);
        }
        else
        {
            Console.WriteLine("Data in thread_{0}'s data slot changed to: {1,3}",
                threadId, newSlotData);
        }
    }
}

open System
open System.Threading

module Slot =
    let private randomGenerator = Random()

    let slotTest () =
        // Set random data in each thread's data slot.
        let slotData = randomGenerator.Next(1, 200)
        let threadId = Thread.CurrentThread.ManagedThreadId

        Thread.SetData(Thread.GetNamedDataSlot "Random", slotData)

        // Show what was saved in the thread's data slot.
        printfn $"Data stored in thread_{threadId}'s data slot: {slotData, 3}"

        // Allow other threads time to execute SetData to show
        // that a thread's data slot is unique to itself.
        Thread.Sleep 1000

        let newSlotData = Thread.GetData(Thread.GetNamedDataSlot "Random") :?> int

        if newSlotData = slotData then
            printfn $"Data in thread_{threadId}'s data slot is still: {newSlotData, 3}"
        else
            printfn $"Data in thread_{threadId}'s data slot changed to: {newSlotData, 3}"

let newThreads =
    [| for _ = 0 to 3 do
           let thread = Thread Slot.slotTest
           thread.Start()
           thread |]

Thread.Sleep 2000

for tread in newThreads do
    tread.Join()
    printfn $"Thread_{tread.ManagedThreadId} finished."

Imports System.Threading

Class Test
    Public Shared Sub Main()
        Dim newThreads(3) As Thread
        Dim i As Integer
        For i = 0 To newThreads.Length - 1
            newThreads(i) = _
                New Thread(New ThreadStart(AddressOf Slot.SlotTest))
            newThreads(i).Start()
        Next i
        Thread.Sleep(2000)
        For i = 0 To newThreads.Length - 1
            newThreads(i).Join()
            Console.WriteLine("Thread_{0} finished.", _
                newThreads(i).ManagedThreadId)
        Next i
    End Sub
End Class

Class Slot
    Private Shared randomGenerator As New Random()

    Public Shared Sub SlotTest()
        ' Set random data in each thread's data slot.
        Dim slotData As Integer = randomGenerator.Next(1, 200)
        Dim threadId As Integer = Thread.CurrentThread.ManagedThreadId

        Thread.SetData(
            Thread.GetNamedDataSlot("Random"),
            slotData)

        ' Show what was saved in the thread's data slot.
        Console.WriteLine("Data stored in thread_{0}'s data slot: {1,3}",
            threadId, slotData)

        ' Allow other threads time to execute SetData to show
        ' that a thread's data slot is unique to itself.
        Thread.Sleep(1000)

        Dim newSlotData As Integer = _
            CType(Thread.GetData(Thread.GetNamedDataSlot("Random")), Integer)

        If newSlotData = slotData Then
            Console.WriteLine("Data in thread_{0}'s data slot is still: {1,3}",
                threadId, newSlotData)
        Else
            Console.WriteLine("Data in thread_{0}'s data slot changed to: {1,3}",
                threadId, newSlotData)
        End If
    End Sub
End Class

설명

Important

.NET Framework는 TLS(스레드 로컬 스토리지)를 사용하기 위한 두 가지 메커니즘인 스레드 상대 정적 필드(즉, ThreadStaticAttribute 특성으로 표시된 필드) 및 데이터 슬롯을 제공합니다. 스레드 상대 정적 필드는 데이터 슬롯보다 훨씬 더 나은 성능을 제공하고 컴파일 시간 형식 검사를 사용하도록 설정합니다. TLS 사용에 대한 자세한 내용은 스레드 로컬 스토리지: Thread-Relative 정적 필드 및 데이터 슬롯을 참조하세요.

스레드는 로컬 저장소 메모리 메커니즘을 사용하여 스레드별 데이터를 저장합니다. 공용 언어 런타임은 다중 슬롯 데이터 저장소 배열을 만들 때 각 프로세스에 할당합니다. 스레드는 데이터 저장소에 데이터 슬롯을 할당하고, 슬롯에 데이터 값을 저장 및 검색하고, 스레드가 만료된 후 다시 사용할 수 있는 슬롯을 해제할 수 있습니다. 데이터 슬롯은 스레드당 고유합니다. 다른 스레드(자식 스레드도 아님)는 해당 데이터를 가져올 수 없습니다.

메서드가 아직 할당되지 않은 경우 슬롯을 할당하기 때문에 AllocateNamedDataSlot 명명된 데이터 슬롯을 할당하는 데 메서드를 사용할 GetNamedDataSlot 필요가 없습니다.

메모

메서드를 AllocateNamedDataSlot 사용하는 경우 지정된 이름의 슬롯이 이미 할당된 경우 예외를 throw하므로 프로그램 시작 시 주 스레드에서 호출해야 합니다. 슬롯이 이미 할당되었는지 여부를 테스트할 수 있는 방법은 없습니다.

이 메서드로 할당된 슬롯은 .을 사용하여 FreeNamedDataSlot해제해야 합니다.

적용 대상

추가 정보

피드백

이 페이지가 도움이 되었나요?