Interlocked Kelas

Definisi

Ruang nama:

System.Threading

Rakitan:

System.Threading.dll

Sumber:

Interlocked.cs

Menyediakan operasi atom untuk variabel yang dibagikan oleh beberapa utas.

public ref class Interlocked abstract sealed

public static class Interlocked

type Interlocked = class

Public Class Interlocked

Warisan

Object

Interlocked

Contoh

Contoh kode berikut menunjukkan mekanisme penguncian sumber daya yang aman untuk utas.

using namespace System;
using namespace System::Threading;

const int numThreads = 10;
const int numThreadIterations = 5;
ref class MyInterlockedExchangeExampleClass
{
public:
   static void MyThreadProc()
   {
      for ( int i = 0; i < numThreadIterations; i++ )
      {
         UseResource();
         
         //Wait 1 second before next attempt.
         Thread::Sleep( 1000 );

      }
   }


private:
   //A simple method that denies reentrancy.
   static bool UseResource()
   {
      
      //0 indicates that the method is not in use.
      if ( 0 == Interlocked::Exchange( usingResource, 1 ) )
      {
         Console::WriteLine( " {0} acquired the lock", Thread::CurrentThread->Name );
         
         //Code to access a resource that is not thread safe would go here.
         //Simulate some work
         Thread::Sleep( 500 );
         Console::WriteLine( " {0} exiting lock", Thread::CurrentThread->Name );
         
         //Release the lock
         Interlocked::Exchange( usingResource, 0 );
         return true;
      }
      else
      {
         Console::WriteLine( " {0} was denied the lock", Thread::CurrentThread->Name );
         return false;
      }
   }


   //0 for false, 1 for true.
   static int usingResource;
};

int main()
{
   Thread^ myThread;
   Random^ rnd = gcnew Random;
   for ( int i = 0; i < numThreads; i++ )
   {
      myThread = gcnew Thread( gcnew ThreadStart( MyInterlockedExchangeExampleClass::MyThreadProc ) );
      myThread->Name = String::Format( "Thread {0}", i + 1 );
      
      //Wait a random amount of time before starting next thread.
      Thread::Sleep( rnd->Next( 0, 1000 ) );
      myThread->Start();

   }
}

using System;
using System.Threading;

namespace InterlockedExchange_Example
{
    class MyInterlockedExchangeExampleClass
    {
        //0 for false, 1 for true.
        private static int usingResource = 0;

        private const int numThreadIterations = 5;
        private const int numThreads = 10;

        static void Main()
        {
            Thread myThread;
            Random rnd = new Random();

            for(int i = 0; i < numThreads; i++)
            {
                myThread = new Thread(new ThreadStart(MyThreadProc));
                myThread.Name = String.Format("Thread{0}", i + 1);
            
                //Wait a random amount of time before starting next thread.
                Thread.Sleep(rnd.Next(0, 1000));
                myThread.Start();
            }
        }

        private static void MyThreadProc()
        {
            for(int i = 0; i < numThreadIterations; i++)
            {
                UseResource();
            
                //Wait 1 second before next attempt.
                Thread.Sleep(1000);
            }
        }

        //A simple method that denies reentrancy.
        static bool UseResource()
        {
            //0 indicates that the method is not in use.
            if(0 == Interlocked.Exchange(ref usingResource, 1))
            {
                Console.WriteLine("{0} acquired the lock", Thread.CurrentThread.Name);
            
                //Code to access a resource that is not thread safe would go here.
            
                //Simulate some work
                Thread.Sleep(500);

                Console.WriteLine("{0} exiting lock", Thread.CurrentThread.Name);
            
                //Release the lock
                Interlocked.Exchange(ref usingResource, 0);
                return true;
            }
            else
            {
                Console.WriteLine("   {0} was denied the lock", Thread.CurrentThread.Name);
                return false;
            }
        }
    }
}

Imports System.Threading

Namespace InterlockedExchange_Example
    Class MyInterlockedExchangeExampleClass
        '0 for false, 1 for true.
        Private Shared usingResource As Integer = 0

        Private Const numThreadIterations As Integer = 5
        Private Const numThreads As Integer = 10

        <MTAThread> _
        Shared Sub Main()
            Dim myThread As Thread
            Dim rnd As New Random()

            Dim i As Integer
            For i = 0 To numThreads - 1
                myThread = New Thread(AddressOf MyThreadProc)
                myThread.Name = String.Format("Thread{0}", i + 1)

                'Wait a random amount of time before starting next thread.
                Thread.Sleep(rnd.Next(0, 1000))
                myThread.Start()
            Next i
        End Sub

        Private Shared Sub MyThreadProc()
            Dim i As Integer
            For i = 0 To numThreadIterations - 1
                UseResource()

                'Wait 1 second before next attempt.
                Thread.Sleep(1000)
            Next i
        End Sub 

        'A simple method that denies reentrancy.
        Shared Function UseResource() As Boolean
            '0 indicates that the method is not in use.
            If 0 = Interlocked.Exchange(usingResource, 1) Then
                Console.WriteLine("{0} acquired the lock", Thread.CurrentThread.Name)

                'Code to access a resource that is not thread safe would go here.
                'Simulate some work
                Thread.Sleep(500)

                Console.WriteLine("{0} exiting lock", Thread.CurrentThread.Name)

                'Release the lock
                Interlocked.Exchange(usingResource, 0)
                Return True
            Else
                Console.WriteLine("   {0} was denied the lock", Thread.CurrentThread.Name)
                Return False
            End If
        End Function 
    End Class 
End Namespace

Keterangan

Metode kelas ini membantu melindungi dari kesalahan yang dapat terjadi ketika penjadwal beralih konteks saat utas memperbarui variabel yang dapat diakses oleh utas lain, atau ketika dua utas dijalankan secara bersamaan pada prosesor terpisah. Anggota kelas ini tidak melemparkan pengecualian.

Metode Increment dan Decrement meningkatkan atau menurunkan variabel dan menyimpan nilai yang dihasilkan dalam satu operasi. Di sebagian besar komputer, menaikkan variabel bukanlah operasi atomik, memerlukan langkah-langkah berikut:

1. Muat nilai dari variabel instans ke dalam register.

2. Kenaikan atau penurunan nilai.

3. Simpan nilai dalam variabel instans.

Jika Anda tidak menggunakan Increment dan Decrement, utas dapat didahului setelah menjalankan dua langkah pertama. Utas lain kemudian dapat menjalankan ketiga langkah tersebut. Ketika utas pertama melanjutkan eksekusi, utas ini menimpa nilai dalam variabel instans, dan efek kenaikan atau penurunan yang dilakukan oleh utas kedua hilang.

Metode Add secara atomik menambahkan nilai bilangan bulat ke variabel bilangan bulat dan mengembalikan nilai baru variabel.

Metode Exchange secara atomis bertukar nilai variabel yang ditentukan. Metode CompareExchange menggabungkan dua operasi: membandingkan dua nilai dan menyimpan nilai ketiga dalam salah satu variabel, berdasarkan hasil perbandingan. Operasi perbandingan dan pertukaran dilakukan sebagai operasi atomik.

Pastikan bahwa setiap akses tulis atau baca ke variabel bersama bersifat atomik. Jika tidak, data mungkin rusak atau nilai yang dimuat mungkin salah.

Metode

Add(Int32, Int32)	Menambahkan dua bilangan bulat 32-bit dan mengganti bilangan bulat pertama dengan jumlah, sebagai operasi atom.
Add(Int64, Int64)	Menambahkan dua bilangan bulat 64-bit dan mengganti bilangan bulat pertama dengan jumlah, sebagai operasi atom.
Add(UInt32, UInt32)	Menambahkan dua bilangan bulat yang tidak ditandatangani 32-bit dan mengganti bilangan bulat pertama dengan jumlah, sebagai operasi atom.
Add(UInt64, UInt64)	Menambahkan dua bilangan bulat yang tidak ditandatangani 64-bit dan mengganti bilangan bulat pertama dengan jumlah, sebagai operasi atom.
And(Int32, Int32)	Bitwise "ands" dua bilangan bulat bertanda tangan 32-bit dan mengganti bilangan bulat pertama dengan hasilnya, sebagai operasi atom.
And(Int64, Int64)	Bitwise "ands" dua bilangan bulat bertanda tangan 64-bit dan mengganti bilangan bulat pertama dengan hasilnya, sebagai operasi atom.
And(UInt32, UInt32)	Bitwise "ands" dua bilangan bulat yang tidak ditandatangani 32-bit dan mengganti bilangan bulat pertama dengan hasilnya, sebagai operasi atom.
And(UInt64, UInt64)	Bitwise "ands" dua bilangan bulat 64-bit tidak ditandatangani dan mengganti bilangan bulat pertama dengan hasilnya, sebagai operasi atom.
CompareExchange(Double, Double, Double)	Membandingkan dua angka titik float presisi ganda untuk kesetaraan dan, jika sama, menggantikan nilai pertama.
CompareExchange(Int32, Int32, Int32)	Membandingkan dua bilangan bulat bertanda tangan 32-bit untuk kesetaraan dan, jika sama, menggantikan nilai pertama.
CompareExchange(Int64, Int64, Int64)	Membandingkan dua bilangan bulat bertanda tangan 64-bit untuk kesetaraan dan, jika sama, menggantikan nilai pertama.
CompareExchange(IntPtr, IntPtr, IntPtr)	Membandingkan dua handel atau penunjuk khusus platform untuk kesetaraan dan, jika sama, menggantikan yang pertama.
CompareExchange(Object, Object, Object)	Membandingkan dua objek untuk kesetaraan referensi dan, jika sama, menggantikan objek pertama.
CompareExchange(Single, Single, Single)	Membandingkan dua angka titik float presisi tunggal untuk kesetaraan dan, jika sama, menggantikan nilai pertama.
CompareExchange(UInt32, UInt32, UInt32)	Membandingkan dua bilangan bulat yang tidak ditandatangani 32-bit untuk kesetaraan dan, jika sama, menggantikan nilai pertama.
CompareExchange(UInt64, UInt64, UInt64)	Membandingkan dua bilangan bulat 64-bit yang tidak ditandatangani untuk kesetaraan dan, jika sama, menggantikan nilai pertama.
CompareExchange(UIntPtr, UIntPtr, UIntPtr)	Membandingkan dua handel atau penunjuk khusus platform untuk kesetaraan dan, jika sama, menggantikan yang pertama.
CompareExchange<T>(T, T, T)	Membandingkan dua instans jenis referensi yang ditentukan T untuk kesetaraan referensi dan, jika sama, menggantikan yang pertama.
Decrement(Int32)	Mengurangi variabel tertentu dan menyimpan hasilnya, sebagai operasi atom.
Decrement(Int64)	Mengurangi variabel yang ditentukan dan menyimpan hasilnya, sebagai operasi atom.
Decrement(UInt32)	Mengurangi variabel tertentu dan menyimpan hasilnya, sebagai operasi atom.
Decrement(UInt64)	Mengurangi variabel tertentu dan menyimpan hasilnya, sebagai operasi atom.
Exchange(Double, Double)	Mengatur angka titik float presisi ganda ke nilai tertentu dan mengembalikan nilai asli, sebagai operasi atomik.
Exchange(Int32, Int32)	Mengatur bilangan bulat bertanda tangan 32-bit ke nilai tertentu dan mengembalikan nilai asli, sebagai operasi atomik.
Exchange(Int64, Int64)	Mengatur bilangan bulat bertanda tangan 64-bit ke nilai tertentu dan mengembalikan nilai asli, sebagai operasi atomik.
Exchange(IntPtr, IntPtr)	Mengatur handel atau penunjuk khusus platform ke nilai tertentu dan mengembalikan nilai asli, sebagai operasi atomik.
Exchange(Object, Object)	Mengatur objek ke nilai tertentu dan mengembalikan referensi ke objek asli, sebagai operasi atomik.
Exchange(Single, Single)	Mengatur angka titik float presisi tunggal ke nilai tertentu dan mengembalikan nilai asli, sebagai operasi atomik.
Exchange(UInt32, UInt32)	Mengatur bilangan bulat yang tidak ditandatangani 32-bit ke nilai tertentu dan mengembalikan nilai asli, sebagai operasi atomik.
Exchange(UInt64, UInt64)	Mengatur bilangan bulat yang tidak ditandatangani 64-bit ke nilai tertentu dan mengembalikan nilai asli, sebagai operasi atomik.
Exchange(UIntPtr, UIntPtr)	Mengatur handel atau penunjuk khusus platform ke nilai tertentu dan mengembalikan nilai asli, sebagai operasi atomik.
Exchange<T>(T, T)	Mengatur variabel dari jenis yang ditentukan T ke nilai tertentu dan mengembalikan nilai asli, sebagai operasi atomik.
Increment(Int32)	Menaikkan variabel tertentu dan menyimpan hasilnya, sebagai operasi atom.
Increment(Int64)	Menaikkan variabel tertentu dan menyimpan hasilnya, sebagai operasi atom.
Increment(UInt32)	Menaikkan variabel tertentu dan menyimpan hasilnya, sebagai operasi atom.
Increment(UInt64)	Menaikkan variabel tertentu dan menyimpan hasilnya, sebagai operasi atom.
MemoryBarrier()	Menyinkronkan akses memori sebagai berikut: Prosesor yang menjalankan utas saat ini tidak dapat menyusun ulang instruksi sedaya sehingga memori mengakses sebelum panggilan untuk MemoryBarrier() dijalankan setelah akses memori yang mengikuti panggilan ke MemoryBarrier().
MemoryBarrierProcessWide()	Menyediakan hambatan memori di seluruh proses yang memastikan bahwa membaca dan menulis dari CPU apa pun tidak dapat bergerak melintasi penghalang.
Or(Int32, Int32)	Bitwise "ors" dua bilangan bulat bertanda tangan 32-bit dan mengganti bilangan bulat pertama dengan hasilnya, sebagai operasi atom.
Or(Int64, Int64)	Bitwise "ors" dua bilangan bulat bertanda tangan 64-bit dan mengganti bilangan bulat pertama dengan hasilnya, sebagai operasi atom.
Or(UInt32, UInt32)	Bitwise "ors" dua bilangan bulat yang tidak ditandatangani 32-bit dan mengganti bilangan bulat pertama dengan hasilnya, sebagai operasi atom.
Or(UInt64, UInt64)	Bitwise "ors" dua bilangan bulat 64-bit yang tidak ditandatangani dan mengganti bilangan bulat pertama dengan hasilnya, sebagai operasi atom.
Read(Int64)	Mengembalikan nilai 64-bit, yang dimuat sebagai operasi atom.
Read(UInt64)	Mengembalikan nilai yang tidak ditandatangani 64-bit, dimuat sebagai operasi atom.

Keamanan Thread

Jenis ini aman untuk utas.

Lihat juga

• Managed Threading
• Ringkasan primitif sinkronisasi