Thread.AllocateDataSlot Metoda

Definice

Přidělí nepojmenované datové sloty na všechna vlákna.Allocates an unnamed data slot on all the threads. Pro lepší výkon použijte pole, která jsou označena atributem ThreadStaticAttribute.For better performance, use fields that are marked with the ThreadStaticAttribute attribute instead.

public:
 static LocalDataStoreSlot ^ AllocateDataSlot();
public static LocalDataStoreSlot AllocateDataSlot ();
static member AllocateDataSlot : unit -> LocalDataStoreSlot
Public Shared Function AllocateDataSlot () As LocalDataStoreSlot

Návraty

Přidělená pojmenovaná datová oblast ve všech vláknech.The allocated named data slot on all threads.

Příklady

Tato část obsahuje dva příklady kódu.This section contains two code examples. První příklad ukazuje, jak použít pole, které je označeno atributem ThreadStaticAttribute pro uchovávání informací specifických pro vlákno.The first example shows how to use a field that is marked with the ThreadStaticAttribute attribute to hold thread-specific information. Druhý příklad ukazuje, jak použít datovou datovou oblast ke stejnému účelu.The second example shows how to use a data slot to do the same thing.

První příkladFirst Example

Následující příklad ukazuje, jak použít pole, které je označeno ThreadStaticAttribute pro uchovávání informací specifických pro vlákno.The following example shows how to use a field that is marked with ThreadStaticAttribute to hold thread-specific information. Tento postup poskytuje lepší výkon než metoda, která je uvedena v druhém příkladu.This technique provides better performance than the technique that is shown in the second example.

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

Druhý příkladSecond Example

Následující příklad kódu ukazuje, jak použít datovou oblast k ukládání informací specifických pro vlákno.The following code example demonstrates how to use a data slot to store thread-specific information.

using namespace System;
using namespace System::Threading;
ref class Slot
{
private:
   static Random^ randomGenerator;
   static LocalDataStoreSlot^ localSlot;
   static Slot()
   {
      randomGenerator = gcnew 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() );
   }

};

int main()
{
   array<Thread^>^newThreads = gcnew array<Thread^>(4);
   for ( int i = 0; i < newThreads->Length; i++ )
   {
      newThreads[ i ] = gcnew Thread( gcnew ThreadStart( &Slot::SlotTest ) );
      newThreads[ i ]->Start();

   }
}

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

Poznámky

Důležité

.NET Framework poskytuje dva mechanismy pro použití úložiště thread local (TLS): statická pole v závislosti na vláknech (to znamená pole, která jsou označena atributem ThreadStaticAttribute) a datové sloty.The .NET Framework provides two mechanisms for using thread local storage (TLS): thread-relative static fields (that is, fields that are marked with the ThreadStaticAttribute attribute) and data slots. Statická pole v závislosti na vláknech poskytují mnohem lepší výkon než datové sloty a umožňují kontrolu typu v době kompilace.Thread-relative static fields provide much better performance than data slots, and enable compile-time type checking. Další informace o použití TLS najdete v tématu vlákna v místním úložišti: statická pole a datové sloty související s vláknem.For more information about using TLS, see Thread Local Storage: Thread-Relative Static Fields and Data Slots.

Slot se přiděluje na všechna vlákna.The slot is allocated on all threads.

Vlákna používají mechanismus paměti místního úložiště k ukládání dat specifických pro vlákno.Threads use a local store memory mechanism to store thread-specific data. Modul CLR (Common Language Runtime) přidělí každému procesu při jeho vytvoření pole úložiště dat s více sloty.The common language runtime allocates a multi-slot data store array to each process when it is created. Vlákno může přidělovat datovou patici v úložišti dat, ukládat a načítat datovou hodnotu ve slotu a uvolnit slot pro opakované použití po vypršení platnosti vlákna.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. Datové sloty jsou jedinečné pro každé vlákno.Data slots are unique per thread. Žádná jiná vlákna (ne i podřízené vlákno) může získat tato data.No other thread (not even a child thread) can get that data.

Platí pro

Viz také