Thread.AllocateNamedDataSlot(String) Método

Definición

Espacio de nombres:

System.Threading

Ensamblados:

netstandard.dll, System.Threading.Thread.dll

Source:

Thread.cs

Asigna una ranura de datos con nombre en todos los subprocesos. Para mejorar el rendimiento, en su lugar use campos marcados con el atributo ThreadStaticAttribute.

C#

public static LocalDataStoreSlot AllocateNamedDataSlot(string name);

Parámetros

name

String

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

Devoluciones

LocalDataStoreSlot

Ranura de datos con nombre asignada en todos los subprocesos.

Excepciones

ArgumentException

Ya existe una ranura para datos con el nombre especificado

Ejemplos

Esta sección contiene dos ejemplos de código. En el primer ejemplo se muestra cómo usar un campo marcado con el ThreadStaticAttribute atributo para contener información específica del subproceso. En el segundo ejemplo se muestra cómo usar una ranura de datos para hacer lo mismo.

Primer ejemplo

En el ejemplo siguiente se muestra cómo usar un campo marcado con ThreadStaticAttribute para contener información específica del subproceso. Esta técnica proporciona un mejor rendimiento que la técnica que se muestra en el segundo ejemplo.

C#

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
 */

Segundo ejemplo

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

Nota

El código de ejemplo no usa el AllocateNamedDataSlot método , porque el GetNamedDataSlot método asigna la ranura si aún no se ha asignado. Si se usa el AllocateNamedDataSlot método , se debe llamar en el subproceso principal al iniciar el programa.

C#

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

Comentarios

Importante

.NET Framework proporciona dos mecanismos para usar el almacenamiento local de subprocesos (TLS): campos estáticos relativos a subprocesos (es decir, campos marcados con el ThreadStaticAttribute atributo) y ranuras de datos. Los campos estáticos relativos a subprocesos proporcionan un rendimiento mucho mejor que las ranuras de datos y habilitan la comprobación de tipos en tiempo de compilación. Para obtener más información sobre el uso de TLS, consulte Almacenamiento local de subprocesos: Thread-Relative campos estáticos y ranuras de datos.

Los subprocesos usan un mecanismo de memoria de almacén local para almacenar datos específicos del subproceso. Common Language Runtime asigna una matriz de almacén de datos de varias ranuras a cada proceso cuando se crea. 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. Las ranuras de datos son únicas por subproceso. Ningún otro subproceso (ni siquiera un subproceso secundario) puede obtener esos datos.

No es necesario usar el AllocateNamedDataSlot método para asignar una ranura de datos con nombre, ya que el GetNamedDataSlot método asigna la ranura si aún no se ha asignado.

Nota

Si se usa el AllocateNamedDataSlot método , se debe llamar al subproceso principal en el inicio del programa, ya que produce una excepción si ya se ha asignado una ranura con el nombre especificado. No hay ninguna manera de probar si ya se ha asignado una ranura.

Las ranuras asignadas con este método deben liberarse con FreeNamedDataSlot.

Se aplica a

Consulte también

• Subprocesos y subprocesamiento
• Almacenamiento local para el subproceso: Campos estáticos relacionados con subprocesos y ranuras de datos