Thread.AllocateNamedDataSlot(String) Metode

Definisi

Ruang nama:
System.Threading
Rakitan:
netstandard.dll, System.Threading.Thread.dll
Rakitan:
System.Threading.Thread.dll
Rakitan:
mscorlib.dll
Rakitan:
netstandard.dll
Sumber:
Thread.cs
Sumber:
Thread.cs
Sumber:
Thread.cs
Sumber:
Thread.cs
Sumber:
Thread.cs

Mengalokasikan slot data bernama pada semua utas. Untuk performa yang lebih baik, gunakan bidang yang ditandai dengan atribut sebagai gantinya ThreadStaticAttribute .

public:
 static LocalDataStoreSlot ^ AllocateNamedDataSlot(System::String ^ name);
public static LocalDataStoreSlot AllocateNamedDataSlot(string name);
static member AllocateNamedDataSlot : string -> LocalDataStoreSlot
Public Shared Function AllocateNamedDataSlot (name As String) As LocalDataStoreSlot

Parameter

name
String

Nama slot data yang akan dialokasikan.

Mengembalikan

LocalDataStoreSlot

Slot data bernama yang dialokasikan pada semua utas.

Pengecualian

ArgumentException

Slot data bernama dengan nama yang ditentukan sudah ada.

Contoh

Bagian ini berisi dua contoh kode. Contoh pertama menunjukkan cara menggunakan bidang yang ditandai dengan ThreadStaticAttribute atribut untuk menyimpan informasi khusus utas. Contoh kedua menunjukkan cara menggunakan slot data untuk melakukan hal yang sama.

Contoh Pertama

Contoh berikut menunjukkan cara menggunakan bidang yang ditandai dengan ThreadStaticAttribute untuk menyimpan informasi khusus utas. Teknik ini memberikan performa yang lebih baik daripada teknik yang ditunjukkan dalam contoh kedua.

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

Contoh Kedua

Contoh berikut menunjukkan cara menggunakan slot data bernama untuk menyimpan informasi khusus utas.

Note

Contoh kode tidak menggunakan AllocateNamedDataSlot metode , karena GetNamedDataSlot metode mengalokasikan slot jika belum dialokasikan. AllocateNamedDataSlot Jika metode digunakan, metode harus dipanggil di utas utama saat startup program.

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

Keterangan

Important

.NET Framework menyediakan dua mekanisme untuk menggunakan penyimpanan lokal utas (TLS): bidang statis relatif utas (yaitu, bidang yang ditandai dengan atribut ThreadStaticAttribute) dan slot data. Bidang statis relatif utas memberikan performa yang jauh lebih baik daripada slot data, dan mengaktifkan pemeriksaan jenis waktu kompilasi. Untuk informasi selengkapnya tentang menggunakan TLS, lihat Thread Local Storage: Thread-Relative Bidang Statis dan Slot Data.

Utas menggunakan mekanisme memori penyimpanan lokal untuk menyimpan data khusus utas. Runtime bahasa umum mengalokasikan array penyimpanan data multi-slot untuk setiap proses saat dibuat. Utas dapat mengalokasikan slot data di penyimpanan data, menyimpan dan mengambil nilai data di slot, dan membebaskan slot untuk digunakan kembali setelah utas kedaluwarsa. Slot data unik per utas. Tidak ada utas lain (bahkan utas anak) yang bisa mendapatkan data tersebut.

Tidak perlu menggunakan AllocateNamedDataSlot metode untuk mengalokasikan slot data bernama, karena GetNamedDataSlot metode mengalokasikan slot jika belum dialokasikan.

Note

AllocateNamedDataSlot Jika metode digunakan, metode harus dipanggil di utas utama pada startup program, karena melemparkan pengecualian jika slot dengan nama yang ditentukan telah dialokasikan. Tidak ada cara untuk menguji apakah slot telah dialokasikan.

Slot yang dialokasikan dengan metode ini harus dibebaskan dengan FreeNamedDataSlot.

Berlaku untuk

Lihat juga