Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Thread.FreeNamedDataSlot (String)

 

Publicado: noviembre de 2016

Elimina la asociación entre un nombre y una ranura en todos los subprocesos del proceso. Para mejorar el rendimiento, en su lugar use campos marcados con el atributo ThreadStaticAttribute.

Espacio de nombres:   System.Threading
Ensamblado:  mscorlib (en mscorlib.dll)

[HostProtectionAttribute(SecurityAction.LinkDemand, SharedState = true, 
	ExternalThreading = true)]
public static void FreeNamedDataSlot(
	string name
)

Parámetros

name
Type: System.String

Nombre de la ranura de datos que se va a liberar.

System_CAPS_importantImportante

.NET Framework proporciona dos mecanismos para usar el almacenamiento local de subprocesos (TLS): campos estáticos relacionados con subprocesos (es decir, los campos marcados con el ThreadStaticAttribute atributo) y ranuras de datos. Los campos estáticos relacionados con subprocesos proporcionan un rendimiento mucho mejor que las ranuras de datos y habilitar la comprobación de tipo en tiempo de compilación. Para obtener más información sobre el uso de TLS, consulte Thread Local Storage: Thread-Relative Static Fields and Data Slots.

Después de cualquier subproceso llama FreeNamedDataSlot, ningún otro subproceso que llama a GetNamedDataSlot con el mismo nombre asignará una nueva ranura asociada al nombre. Las llamadas subsiguientes a GetNamedDataSlot ningún subproceso devolverá la nueva ranura. Sin embargo, cualquier subproceso que aún tiene un System.LocalDataStoreSlot devuelto por una llamada anterior a GetNamedDataSlot puede seguir utilizando la ranura antigua.

Se libera una ranura que se ha asociado con el nombre solo cuando cada LocalDataStoreSlot que obtuvo antes de llamar a FreeNamedDataSlot se ha liberado y recolección.

Subprocesos utilizan un mecanismo de memoria de almacenamiento local para almacenar datos específicos del subproceso. Common language runtime asigna una matriz de almacenamiento de datos de varias ranuras a cada proceso cuando se crea. El subproceso puede asignar una ranura de datos del almacén de datos, almacenar y recuperar datos de un valor en la ranura y liberar la ranura para reutilizarlo cuando el subproceso finalice. Las ranuras de datos son únicas para cada subproceso. Ningún otro subproceso (ni siquiera un subproceso secundario) puede obtener esos datos.

Esta sección contiene dos ejemplos de código. El primer ejemplo muestra cómo utilizar un campo que se marca con el ThreadStaticAttribute atributo para almacenar información específica de subprocesos. El segundo ejemplo muestra cómo usar una ranura de datos para hacer lo mismo.

Primer ejemplo

En el ejemplo siguiente se muestra cómo utilizar un campo que se marca con ThreadStaticAttribute para almacenar información específica de subprocesos. Esta técnica proporciona mejor rendimiento que la técnica que se muestra en el segundo ejemplo.

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
{
    [ThreadStaticAttribute]
    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
 */

Segundo ejemplo

En el ejemplo siguiente se muestra cómo usar una ranura de datos para almacenar información específica del subproceso.

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);
        }
    }
}

.NET Framework
Disponible desde 1.1
Volver al principio
Mostrar: