Thread.GetData(LocalDataStoreSlot) Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Recupera el valor de la ranura especificada en el subproceso actual, dentro del dominio actual del subproceso actual. Para mejorar el rendimiento, use campos marcados con el ThreadStaticAttribute atributo en su lugar.
public:
static System::Object ^ GetData(LocalDataStoreSlot ^ slot);public static object GetData(LocalDataStoreSlot slot);static member GetData : LocalDataStoreSlot -> objPublic Shared Function GetData (slot As LocalDataStoreSlot) As ObjectParámetros
- slot
- LocalDataStoreSlot
del LocalDataStoreSlot que se va a obtener el valor.
Devoluciones
Valor recuperado.
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.
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
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
{
static void Main()
{
Thread[] newThreads = new Thread[4];
for(int i = 0; i < newThreads.Length; i++)
{
newThreads[i] = new Thread(
new ThreadStart(Slot.SlotTest));
newThreads[i].Start();
}
}
}
class Slot
{
static Random randomGenerator;
static LocalDataStoreSlot localSlot;
static Slot()
{
randomGenerator = new Random();
localSlot = Thread.AllocateDataSlot();
}
public static void SlotTest()
{
// Set different data in each thread's data slot.
Thread.SetData(localSlot, randomGenerator.Next(1, 200));
// Write the data from each thread's data slot.
Console.WriteLine("Data in thread_{0}'s data slot: {1,3}",
AppDomain.GetCurrentThreadId().ToString(),
Thread.GetData(localSlot).ToString());
// Allow other threads time to execute SetData to show
// that a thread's data slot is unique to the thread.
Thread.Sleep(1000);
Console.WriteLine("Data in thread_{0}'s data slot: {1,3}",
AppDomain.GetCurrentThreadId().ToString(),
Thread.GetData(localSlot).ToString());
}
}
open System
open System.Threading
module Slot =
let randomGenerator = Random()
let localSlot = Thread.AllocateDataSlot()
let slotTest () =
// Set different data in each thread's data slot.
Thread.SetData(localSlot, randomGenerator.Next(1, 200))
// Write the data from each thread's data slot.
printfn $"Data in thread_{AppDomain.GetCurrentThreadId()}'s data slot: {Thread.GetData localSlot, 3}"
// Allow other threads time to execute SetData to show
// that a thread's data slot is unique to the thread.
Thread.Sleep 1000
printfn $"Data in thread_{AppDomain.GetCurrentThreadId()}'s data slot: {Thread.GetData localSlot, 3}"
let newThreads =
[| for _ = 0 to 3 do
let thread = Thread Slot.slotTest
thread.Start()
thread |]
Imports System.Threading
Class Test
<MTAThread> _
Shared Sub Main()
Dim newThreads(3) As Thread
For i As Integer = 0 To newThreads.Length - 1
newThreads(i) = New Thread(AddressOf Slot.SlotTest)
newThreads(i).Start()
Next i
End Sub
End Class
Public Class Slot
Shared randomGenerator As Random
Shared localSlot As LocalDataStoreSlot
Shared Sub New()
randomGenerator = new Random()
localSlot = Thread.AllocateDataSlot()
End Sub
Shared Sub SlotTest()
' Set different data in each thread's data slot.
Thread.SetData(localSlot, randomGenerator.Next(1, 200))
' Write the data from each thread's data slot.
Console.WriteLine("Data in thread_{0}'s data slot: {1,3}", _
AppDomain.GetCurrentThreadId().ToString(), _
Thread.GetData(localSlot).ToString())
' Allow other threads time to execute SetData to show
' that a thread's data slot is unique to the thread.
Thread.Sleep(1000)
' Write the data from each thread's data slot.
Console.WriteLine("Data in thread_{0}'s data slot: {1,3}", _
AppDomain.GetCurrentThreadId().ToString(), _
Thread.GetData(localSlot).ToString())
End Sub
End Class
Comentarios
Importante
.NET Framework proporciona dos mecanismos para usar el almacenamiento local de subprocesos (TLS): campos estáticos relativos al subproceso (es decir, campos marcados con el atributo ThreadStaticAttribute) 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.
Note
GetData es un Shared método que siempre se aplica al subproceso que se está ejecutando actualmente, incluso si se llama mediante una variable que hace referencia a otro subproceso. Para evitar confusiones, use el nombre de clase al llamar a Shared métodos: Dim test As Object = Thread.GetData(testSlot).