Thread.FreeNamedDataSlot(String) Metoda

Definicja

Przestrzeń nazw:: System.Threading

Zestawy:: netstandard.dll, System.Threading.Thread.dll

Zestaw:: System.Threading.Thread.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Źródło:: Thread.cs

Źródło:: Thread.cs

Źródło:: Thread.cs

Źródło:: Thread.cs

Źródło:: Thread.cs

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Eliminuje skojarzenie między nazwą a miejscem dla wszystkich wątków w procesie. Aby uzyskać lepszą wydajność, użyj pól oznaczonych atrybutem ThreadStaticAttribute .

public:
 static void FreeNamedDataSlot(System::String ^ name);

public static void FreeNamedDataSlot(string name);

static member FreeNamedDataSlot : string -> unit

Public Shared Sub FreeNamedDataSlot (name As String)

Parametry

name: String

Nazwa miejsca danych do zwolnienia.

Przykłady

Ta sekcja zawiera dwa przykłady kodu. W pierwszym przykładzie pokazano, jak użyć pola oznaczonego atrybutem ThreadStaticAttribute do przechowywania informacji specyficznych dla wątku. W drugim przykładzie pokazano, jak używać miejsca danych, aby wykonać to samo.

Pierwszy przykład

W poniższym przykładzie pokazano, jak używać pola oznaczonego jako do ThreadStaticAttribute przechowywania informacji specyficznych dla wątku. Ta technika zapewnia lepszą wydajność niż technika pokazana w drugim przykładzie.

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

Drugi przykład

W poniższym przykładzie pokazano, jak używać nazwanego miejsca danych do przechowywania informacji specyficznych dla wątku.

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

Uwagi

Ważna

.NET Framework udostępnia dwa mechanizmy używania magazynu lokalnego wątku (TLS): względne pola statyczne wątku (czyli pola oznaczone atrybutem ThreadStaticAttribute) i miejsca danych. Pola statyczne względne wątkowo zapewniają znacznie lepszą wydajność niż miejsca danych i umożliwiają sprawdzanie typów w czasie kompilacji. Aby uzyskać więcej informacji na temat korzystania z protokołu TLS, zobacz Magazyn lokalny wątku: Thread-Relative pola statyczne i miejsca danych.

Po wywołaniu FreeNamedDataSlotdowolnego wątku każdy inny wątek, który wywołuje GetNamedDataSlot tę samą nazwę, przydzieli nowe miejsce skojarzone z nazwą. Kolejne wywołania GetNamedDataSlot przez dowolny wątek zwracają nowe miejsce. Jednak każdy wątek, który nadal ma zwrócone System.LocalDataStoreSlot przez wcześniejsze wywołanie GetNamedDataSlot , może nadal używać starego gniazda.

Miejsce, które zostało skojarzone z nazwą, jest zwalniane tylko wtedy, gdy każde LocalDataStoreSlot , które zostało uzyskane przed wywołaniem FreeNamedDataSlot , zostało zwolnione i odśmiecane.

Wątki używają mechanizmu pamięci magazynu lokalnego do przechowywania danych specyficznych dla wątków. Środowisko uruchomieniowe języka wspólnego przydziela tablicę magazynów danych z wieloma miejscami do każdego procesu podczas jego tworzenia. Wątek może przydzielić miejsce danych w magazynie danych, zapisać i pobrać wartość danych w miejscu, a następnie zwolnić miejsce do ponownego użycia po wygaśnięciu wątku. Miejsca danych są unikatowe dla każdego wątku. Żaden inny wątek (nawet wątku podrzędnego) nie może pobrać tych danych.

Dotyczy

Zobacz też

Opinia

Czy ta strona była pomocna?