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.AllocateNamedDataSlot (String)

 

Publicado: noviembre de 2016

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.

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

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

Parámetros

name
Type: System.String

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

Valor devuelto

Type: System.LocalDataStoreSlot

Ranura de datos con nombre asignada en todos los subprocesos.

Exception Condition
ArgumentException

Ya existe una ranura para datos con el nombre especificado

System_CAPS_importantImportante

The .NET Framework provides two mechanisms for using thread local storage (TLS): thread-relative static fields (that is, fields that are marked with the T:System.ThreadStaticAttribute attribute) and data slots. Thread-relative static fields provide much better performance than data slots, and enable compile-time type checking. For more information about using TLS, see Thread Local Storage: Thread-Relative Static Fields and Data Slots.

Threads use a local store memory mechanism to store thread-specific data. The common language runtime allocates a multi-slot data store array to each process when it is created. 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. Data slots are unique per thread. No other thread (not even a child thread) can get that data.

It is not necessary to use the M:System.Threading.Thread.AllocateNamedDataSlot(System.String) method to allocate a named data slot, because the M:System.Threading.Thread.GetNamedDataSlot(System.String) method allocates the slot if it has not already been allocated.

System_CAPS_noteNota

If the M:System.Threading.Thread.AllocateNamedDataSlot(System.String) method is used, it should be called in the main thread at program startup, because it throws an exception if a slot with the specified name has already been allocated. There is no way to test whether a slot has already been allocated.

Slots allocated with this method must be freed with M:System.Threading.Thread.FreeNamedDataSlot(System.String).

This section contains two code examples. The first example shows how to use a field that is marked with the T:System.ThreadStaticAttribute attribute to hold thread-specific information. The second example shows how to use a data slot to do the same thing.

First Example

The following example shows how to use a field that is marked with T:System.ThreadStaticAttribute to hold thread-specific information. This technique provides better performance than the technique that is shown in the second example.

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

Second Example

The following example demonstrates how to use a named data slot to store thread-specific information.

System_CAPS_noteNota

The example code does not use the M:System.Threading.Thread.AllocateNamedDataSlot(System.String) method, because the M:System.Threading.Thread.GetNamedDataSlot(System.String) method allocates the slot if it has not already been allocated. If the M:System.Threading.Thread.AllocateNamedDataSlot(System.String) method is used, it should be called in the main thread at program startup.

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: