Thread.FreeNamedDataSlot(String) Método

Definición

Elimina la asociación entre un nombre y una ranura en todos los subprocesos del proceso.Eliminates the association between a name and a slot, for all threads in the process. Para mejorar el rendimiento, en su lugar use campos marcados con el atributo ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

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)

Parámetros

name
String

Nombre de la ranura de datos que se va a liberar.The name of the data slot to be freed.

Ejemplos

Esta sección contiene dos ejemplos de código.This section contains two code examples. En el primer ejemplo se muestra cómo usar un campo marcado con el atributo ThreadStaticAttribute para almacenar información específica del subproceso.The first example shows how to use a field that is marked with the ThreadStaticAttribute attribute to hold thread-specific information. En el segundo ejemplo se muestra cómo usar una ranura de datos para hacer lo mismo.The second example shows how to use a data slot to do the same thing.

Primer ejemploFirst Example

En el ejemplo siguiente se muestra cómo usar un campo marcado con ThreadStaticAttribute para almacenar información específica del subproceso.The following example shows how to use a field that is marked with ThreadStaticAttribute to hold thread-specific information. Esta técnica proporciona un mejor rendimiento que la técnica que se muestra en el segundo ejemplo.This technique provides better performance than the technique that is shown in the second example.

using namespace System;
using namespace System::Threading;

ref class ThreadData
{
private:
   [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 );
   }
};

int main()
{
   for ( int i = 0; i < 3; i++ )
   {
      Thread^ newThread = 
          gcnew Thread( gcnew ThreadStart( 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
 */
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
 */
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

Segundo ejemploSecond Example

En el ejemplo siguiente se muestra cómo usar una ranura de datos con nombre para almacenar información específica del subproceso.The following example demonstrates how to use a named data slot to store thread-specific information.

using namespace System;
using namespace System::Threading;

ref class Slot
{
private:
    static Random^ randomGenerator = gcnew 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);
        }
    }
};

ref class Test
{
public:
    static void Main()
    {
        array<Thread^>^ newThreads = gcnew array<Thread^>(4);
        int i;
        for (i = 0; i < newThreads->Length; i++)
        {
            newThreads[i] =
                gcnew Thread(gcnew 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);
        }
    }
};

int main()
{
    Test::Main();
}
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);
        }
    }
}
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

Comentarios

Importante

El .NET Framework proporciona dos mecanismos para usar el almacenamiento local de subprocesos (TLS): campos estáticos relacionados con subprocesos (es decir, campos marcados con el atributo ThreadStaticAttribute) y ranuras de datos.The .NET Framework provides two mechanisms for using thread local storage (TLS): thread-relative static fields (that is, fields that are marked with the ThreadStaticAttribute attribute) and data slots. Los campos estáticos relacionados con subprocesos proporcionan un rendimiento mucho mejor que las ranuras de datos y habilitan la comprobación de tipos en tiempo de compilación.Thread-relative static fields provide much better performance than data slots, and enable compile-time type checking. Para obtener más información sobre el uso de TLS, vea almacenamiento local para el subproceso: campos estáticos relacionados con subprocesos y ranuras de datos.For more information about using TLS, see Thread Local Storage: Thread-Relative Static Fields and Data Slots.

Después de que cualquier subproceso llame a FreeNamedDataSlot, cualquier otro subproceso que llame a GetNamedDataSlot con el mismo nombre asignará una nueva ranura asociada al nombre.After any thread calls FreeNamedDataSlot, any other thread that calls GetNamedDataSlot with the same name will allocate a new slot associated with the name. Las llamadas subsiguientes a GetNamedDataSlot por cualquier subproceso devolverán la nueva ranura.Subsequent calls to GetNamedDataSlot by any thread will return the new slot. Sin embargo, cualquier subproceso que aún tenga un System.LocalDataStoreSlot devuelto por una llamada anterior a GetNamedDataSlot puede seguir usando la ranura antigua.However, any thread that still has a System.LocalDataStoreSlot returned by an earlier call to GetNamedDataSlot can continue to use the old slot.

Una ranura que se ha asociado con un nombre solo se libera cuando cada LocalDataStoreSlot que se obtuvo antes de la llamada a FreeNamedDataSlot se libera y se recolecta como elemento no utilizado.A slot that has been associated with a name is released only when every LocalDataStoreSlot that was obtained prior to the call to FreeNamedDataSlot has been released and garbage-collected.

Los subprocesos usan un mecanismo de memoria del almacén local para almacenar datos específicos del subproceso.Threads use a local store memory mechanism to store thread-specific data. El Common Language Runtime asigna una matriz de almacén de datos de varias ranuras a cada proceso cuando se crea.The common language runtime allocates a multi-slot data store array to each process when it is created. El subproceso puede asignar una ranura de datos en el almacén de datos, almacenar y recuperar un valor de datos en la ranura y liberar la ranura para su reutilización después de que expire el subproceso.The thread can allocate a data slot in the data store, store and retrieve a data value in the slot, and free the slot for reuse after the thread expires. Las ranuras de datos son únicas por subproceso.Data slots are unique per thread. Ningún otro subproceso (ni siquiera un subproceso secundario) puede obtener esos datos.No other thread (not even a child thread) can get that data.

Se aplica a

Consulte también: