Thread.AllocateNamedDataSlot(String) Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Alloca uno slot di dati denominato su tutti i thread. Per ottenere prestazioni migliori, usare i campi contrassegnati con l'attributo ThreadStaticAttribute.
public:
static LocalDataStoreSlot ^ AllocateNamedDataSlot(System::String ^ name);public static LocalDataStoreSlot AllocateNamedDataSlot (string name);static member AllocateNamedDataSlot : string -> LocalDataStoreSlotPublic Shared Function AllocateNamedDataSlot (name As String) As LocalDataStoreSlotParametri
- name
- String
Nome dello slot di dati da allocare.
Restituisce
Slot di dati denominato allocato su tutti i thread.
Eccezioni
Esiste già uno slot di dati denominato con il nome specificato.
Esempio
In questa sezione sono riportati due esempi di codice. Il primo esempio illustra come usare un campo contrassegnato con l'attributo ThreadStaticAttribute per contenere informazioni specifiche del thread. Il secondo esempio illustra come usare uno slot dati per eseguire la stessa operazione.
Primo esempio
Nell'esempio seguente viene illustrato come usare un campo contrassegnato con ThreadStaticAttribute per contenere informazioni specifiche del thread. Questa tecnica offre prestazioni migliori rispetto alla tecnica illustrata nel secondo esempio.
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
*/
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
Secondo esempio
Nell'esempio seguente viene illustrato come usare uno slot di dati denominato per archiviare informazioni specifiche del thread.
Nota
Il codice di esempio non usa il AllocateNamedDataSlot metodo, perché il GetNamedDataSlot metodo alloca lo slot se non è già stato allocato. Se viene usato il AllocateNamedDataSlot metodo, deve essere chiamato nel thread principale all'avvio del programma.
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);
}
}
}
open System
open System.Threading
module Slot =
let private randomGenerator = Random()
let slotTest () =
// Set random data in each thread's data slot.
let slotData = randomGenerator.Next(1, 200)
let threadId = Thread.CurrentThread.ManagedThreadId
Thread.SetData(Thread.GetNamedDataSlot "Random", slotData)
// Show what was saved in the thread's data slot.
printfn $"Data stored in thread_{threadId}'s data slot: {slotData, 3}"
// Allow other threads time to execute SetData to show
// that a thread's data slot is unique to itself.
Thread.Sleep 1000
let newSlotData = Thread.GetData(Thread.GetNamedDataSlot "Random") :?> int
if newSlotData = slotData then
printfn $"Data in thread_{threadId}'s data slot is still: {newSlotData, 3}"
else
printfn $"Data in thread_{threadId}'s data slot changed to: {newSlotData, 3}"
let newThreads =
[| for _ = 0 to 3 do
let thread = Thread Slot.slotTest
thread.Start()
thread |]
Thread.Sleep 2000
for tread in newThreads do
tread.Join()
printfn $"Thread_{tread.ManagedThreadId} finished."
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
Commenti
Importante
.NET Framework fornisce due meccanismi per l'uso dell'archiviazione locale del thread (TLS): campi statici relativi ai thread(ovvero campi contrassegnati con l'attributo ThreadStaticAttribute ) e gli slot di dati. I campi statici relativi al thread offrono prestazioni molto migliori rispetto agli slot dati e consentono il controllo dei tipi di compilazione. Per altre informazioni sull'uso di TLS, vedere Archiviazione locale thread: Thread-Relative campi statici e slot dati.
I thread usano un meccanismo di memoria dell'archivio locale per archiviare dati specifici del thread. Common Language Runtime alloca una matrice di archivi dati a più slot a ogni processo quando viene creata. Il thread può allocare uno slot dati nell'archivio dati, archiviare e recuperare un valore di dati nello slot e liberare lo slot per il riutilizzo dopo la scadenza del thread. Gli slot dati sono univoci per ogni thread. Nessun altro thread (nemmeno un thread figlio) può ottenere tali dati.
Non è necessario usare il AllocateNamedDataSlot metodo per allocare uno slot di dati denominato, perché il GetNamedDataSlot metodo alloca lo slot se non è già stato allocato.
Nota
Se viene usato il AllocateNamedDataSlot metodo, deve essere chiamato nel thread principale all'avvio del programma, perché genera un'eccezione se è già stato allocato uno slot con il nome specificato. Non è possibile verificare se è già stato allocato uno slot.
Gli slot allocati con questo metodo devono essere liberati con FreeNamedDataSlot.
