Thread.FreeNamedDataSlot(String) Yöntem

Tanım

Ad Alanı:

System.Threading

Bütünleştirilmiş Kod:

System.Threading.Thread.dll

Bütünleştirilmiş Kod:

netstandard.dll

Bütünleştirilmiş Kod:

mscorlib.dll

İşlemdeki tüm iş parçacıkları için bir ad ve bir yuva arasındaki ilişkilendirmeyi ortadan kaldırır. Daha iyi performans için ThreadStaticAttribute bunun yerine özniteliğiyle işaretlenmiş alanları kullanın.

public:
 static void FreeNamedDataSlot(System::String ^ name);

public static void FreeNamedDataSlot (string name);

static member FreeNamedDataSlot : string -> unit

Public Shared Sub FreeNamedDataSlot (name As String)

Parametreler

name

String

Boşaltılacak veri yuvasının adı.

Örnekler

Bu bölüm iki kod örneği içerir. İlk örnek, ThreadStaticAttribute iş parçacığına özgü bilgileri tutmak için özniteliğiyle işaretlenmiş bir alanın nasıl kullanıldığını gösterir. İkinci örnek, aynı şeyi yapmak için bir veri yuvasını nasıl kullanacağınızı gösterir.

İlk örnek

Aşağıdaki örnek, ThreadStaticAttribute iş parçacığına özgü bilgileri tutmak için ile işaretlenen bir alanın nasıl kullanıldığını gösterir. Bu teknik, ikinci örnekte gösterilen tekniğinden daha iyi performans sağlar.

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

İkinci örnek

Aşağıdaki örnek, bir adlandırılmış veri yuvasının iş parçacığına özgü bilgileri depolamak için nasıl kullanılacağını gösterir.

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

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

Açıklamalar

Önemli

.NET Framework, iş parçacığı yerel depolaması (TLS) kullanmak için iki mekanizma sağlar: iş parçacığı göreli statik alanları (yani, özniteliğiyle işaretlenen alanlar ThreadStaticAttribute ) ve veri yuvaları. İş parçacığı göreli statik alanları, veri yuvalardan çok daha iyi performans sağlar ve derleme zamanı tür denetimini etkinleştirir. TLS kullanma hakkında daha fazla bilgi için bkz. Thread Local Depolama: Thread-Relative statik alanları ve veri yuvaları.

Herhangi bir iş parçacığı çağrıldıktan sonra FreeNamedDataSlot , GetNamedDataSlot aynı ada sahip başka bir iş parçacığı adıyla ilişkili yeni bir yuva ayırır. GetNamedDataSlotHerhangi bir iş parçacığı tarafından yapılan sonraki çağrılar yeni yuvayı döndürür. Ancak, System.LocalDataStoreSlot daha önceki bir çağrı tarafından döndürülen herhangi bir iş parçacığı GetNamedDataSlot eski yuvayı kullanmaya devam edebilir.

Bir ad ile ilişkilendirilmiş bir yuva, yalnızca ' a yapılan LocalDataStoreSlot çağrıdan önce alındıkça FreeNamedDataSlot ve atık olarak toplandıktan sonra serbest bırakılır.

İş parçacıkları, iş parçacığına özgü verileri depolamak için yerel bir depo bellek mekanizması kullanır. Ortak dil çalışma zamanı, oluşturulduğunda her bir işleme çok yuvalı bir veri deposu dizisi ayırır. İş parçacığı veri deposunda bir veri yuvası ayırabilir, yuvada bir veri değeri saklayabilir ve alabilir ve iş parçacığının süresi dolduktan sonra yuvayı yeniden kullanım için serbest bırakabilirsiniz. Veri yuvaları iş parçacığı başına benzersizdir. Diğer iş parçacığı (alt iş parçacığı bile değil) bu verileri alabilir.

Ayrıca bkz.

• İş Parçacıkları ve İş Parçacığı Oluşturma
• İş Parçacığında Yerel Depolama: İş Parçacığı Göreli Statik Alanları ve Veri Yuvaları