Interlocked Klasa

Definicja

Zapewnia operacje niepodzielne dla zmiennych, które są współużytkowane przez wiele wątków.Provides atomic operations for variables that are shared by multiple threads.

public ref class Interlocked abstract sealed
public ref class Interlocked sealed
public static class Interlocked
public sealed class Interlocked
type Interlocked = class
Public Class Interlocked
Public NotInheritable Class Interlocked
Dziedziczenie
Interlocked

Przykłady

Poniższy przykład kodu przedstawia mechanizm blokowania zasobów z bezpiecznym wątkiem.The following code example shows a thread-safe resource locking mechanism.

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 

Uwagi

Metody tej klasy pomagają chronić przed błędami, które mogą wystąpić, gdy harmonogram przełącza konteksty, gdy wątek aktualizuje zmienną, do której można uzyskać dostęp za pomocą innych wątków, lub gdy dwa wątki są wykonywane współbieżnie na oddzielnych procesorach.The methods of this class help protect against errors that can occur when the scheduler switches contexts while a thread is updating a variable that can be accessed by other threads, or when two threads are executing concurrently on separate processors. Elementy członkowskie tej klasy nie generują wyjątków.The members of this class do not throw exceptions.

IncrementMetody i Decrement zwiększają lub zmniejszają zmienną i zapisują wartość powstającą w ramach jednej operacji.The Increment and Decrement methods increment or decrement a variable and store the resulting value in a single operation. Na większości komputerów zwiększenie zmiennej nie jest operacją niepodzielną, co wymaga wykonania następujących czynności:On most computers, incrementing a variable is not an atomic operation, requiring the following steps:

  1. Załaduj wartość z zmiennej wystąpienia do rejestru.Load a value from an instance variable into a register.

  2. Zwiększ lub zmniejsz wartość.Increment or decrement the value.

  3. Zapisz wartość w zmiennej wystąpienia.Store the value in the instance variable.

Jeśli nie używasz Increment i Decrement , wątek może zostać przeniesiona po wykonaniu pierwszych dwóch kroków.If you do not use Increment and Decrement, a thread can be preempted after executing the first two steps. Następnie można wykonać wszystkie trzy kroki z innego wątku.Another thread can then execute all three steps. Gdy pierwszy wątek wznawia wykonywanie, zastępuje wartość w zmiennej wystąpienia, a efekt przyrostu lub zmniejszenia wykonywany przez drugi wątek zostanie utracony.When the first thread resumes execution, it overwrites the value in the instance variable, and the effect of the increment or decrement performed by the second thread is lost.

AddMetoda niepodzielnie dodaje wartość całkowitą do zmiennej całkowitej i zwraca nową wartość zmiennej.The Add method atomically adds an integer value to an integer variable and returns the new value of the variable.

ExchangeMetoda niepodzielnie wymienia wartości określonych zmiennych.The Exchange method atomically exchanges the values of the specified variables. CompareExchangeMetoda łączy dwie operacje: porównywanie dwóch wartości i przechowywanie trzeciej wartości w jednej ze zmiennych, na podstawie wyniku porównania.The CompareExchange method combines two operations: comparing two values and storing a third value in one of the variables, based on the outcome of the comparison. Operacje porównania i wymiany są wykonywane jako operacja niepodzielna.The compare and exchange operations are performed as an atomic operation.

Upewnij się, że dowolny dostęp do zapisu i odczytu do zmiennej udostępnionej jest niepodzielny.Ensure that any write or read access to a shared variable is atomic. W przeciwnym razie dane mogą być uszkodzone lub załadowana wartość może być niepoprawna.Otherwise, the data might be corrupted or the loaded value might be incorrect.

Metody

Add(Int32, Int32)

Dodaje 2 32-bitowe liczby całkowite i zastępuje pierwszą liczbę całkowitą z sumą jako operację niepodzielną.Adds two 32-bit integers and replaces the first integer with the sum, as an atomic operation.

Add(Int64, Int64)

Dodaje 2 64-bitowe liczby całkowite i zastępuje pierwszą liczbę całkowitą z sumą jako operację niepodzielną.Adds two 64-bit integers and replaces the first integer with the sum, as an atomic operation.

Add(UInt32, UInt32)

Dodaje 2 32-bitowe liczby całkowite bez znaku i zastępuje pierwszą liczbę całkowitą z sumą jako operację niepodzielną.Adds two 32-bit unsigned integers and replaces the first integer with the sum, as an atomic operation.

Add(UInt64, UInt64)

Dodaje 2 64-bitowe liczby całkowite bez znaku i zastępuje pierwszą liczbę całkowitą z sumą jako operację niepodzielną.Adds two 64-bit unsigned integers and replaces the first integer with the sum, as an atomic operation.

And(Int32, Int32)

Bitowe "ands" 2 32-bitowe liczby całkowite ze znakiem i zamieniają pierwszą liczbę całkowitą z wynikiem, jako operację niepodzielną.Bitwise "ands" two 32-bit signed integers and replaces the first integer with the result, as an atomic operation.

And(Int64, Int64)

Bitowe "ands" 2 64-bitowe liczby całkowite ze znakiem i zamieniają pierwszą liczbę całkowitą z wynikiem, jako operację niepodzielną.Bitwise "ands" two 64-bit signed integers and replaces the first integer with the result, as an atomic operation.

And(UInt32, UInt32)

Bitowe "ands" 2 32-bitowe liczby całkowite bez znaku i zamieniają pierwszą liczbę całkowitą na wynik jako operację niepodzielną.Bitwise "ands" two 32-bit unsigned integers and replaces the first integer with the result, as an atomic operation.

And(UInt64, UInt64)

Bitowe "ands" 2 64-bitowe liczby całkowite bez znaku i zamieniają pierwszą liczbę całkowitą na wynik jako operację niepodzielną.Bitwise "ands" two 64-bit unsigned integers and replaces the first integer with the result, as an atomic operation.

CompareExchange(Double, Double, Double)

Porównuje dwie liczby zmiennoprzecinkowe podwójnej precyzji dla równości i, jeśli są równe, zastępuje pierwszą wartość.Compares two double-precision floating point numbers for equality and, if they are equal, replaces the first value.

CompareExchange(Int32, Int32, Int32)

Porównuje 2 32-bitowe liczby całkowite ze znakiem równości i, jeśli są równe, zastępuje pierwszą wartość.Compares two 32-bit signed integers for equality and, if they are equal, replaces the first value.

CompareExchange(Int64, Int64, Int64)

Porównuje 2 64-bitowe liczby całkowite ze znakiem równości i, jeśli są równe, zastępuje pierwszą wartość.Compares two 64-bit signed integers for equality and, if they are equal, replaces the first value.

CompareExchange(IntPtr, IntPtr, IntPtr)

Porównuje dwa uchwyty specyficzne dla platformy lub wskaźniki dla równości i, jeśli są równe, zastępuje pierwszy z nich.Compares two platform-specific handles or pointers for equality and, if they are equal, replaces the first one.

CompareExchange(Object, Object, Object)

Porównuje dwa obiekty pod kątem równości odwołań i, jeśli są równe, zastępuje pierwszy obiekt.Compares two objects for reference equality and, if they are equal, replaces the first object.

CompareExchange(Single, Single, Single)

Porównuje dwie liczby zmiennoprzecinkowe o pojedynczej precyzji dla równości i, jeśli są równe, zastępuje pierwszą wartość.Compares two single-precision floating point numbers for equality and, if they are equal, replaces the first value.

CompareExchange(UInt32, UInt32, UInt32)

Porównuje 2 32-bitowe liczby całkowite bez znaku dla równości i, jeśli są równe, zastępuje pierwszą wartość.Compares two 32-bit unsigned integers for equality and, if they are equal, replaces the first value.

CompareExchange(UInt64, UInt64, UInt64)

Porównuje 2 64-bitowe liczby całkowite bez znaku dla równości i, jeśli są równe, zastępuje pierwszą wartość.Compares two 64-bit unsigned integers for equality and, if they are equal, replaces the first value.

CompareExchange<T>(T, T, T)

Porównuje dwa wystąpienia określonego typu referencyjnego T dla równości odwołań i, jeśli są równe, zastępuje pierwszy z nich.Compares two instances of the specified reference type T for reference equality and, if they are equal, replaces the first one.

Decrement(Int32)

Zmniejsza określoną zmienną i zapisuje wynik jako operację niepodzielną.Decrements a specified variable and stores the result, as an atomic operation.

Decrement(Int64)

Zmniejsza określoną zmienną i zapisuje wynik jako operację niepodzielną.Decrements the specified variable and stores the result, as an atomic operation.

Decrement(UInt32)

Zmniejsza określoną zmienną i zapisuje wynik jako operację niepodzielną.Decrements a specified variable and stores the result, as an atomic operation.

Decrement(UInt64)

Zmniejsza określoną zmienną i zapisuje wynik jako operację niepodzielną.Decrements a specified variable and stores the result, as an atomic operation.

Exchange(Double, Double)

Ustawia liczbę zmiennoprzecinkową o podwójnej precyzji na określoną wartość i zwraca oryginalną wartość jako operację niepodzielną.Sets a double-precision floating point number to a specified value and returns the original value, as an atomic operation.

Exchange(Int32, Int32)

Ustawia 32-bitową liczbę całkowitą ze znakiem na określoną wartość i zwraca oryginalną wartość jako operację niepodzielną.Sets a 32-bit signed integer to a specified value and returns the original value, as an atomic operation.

Exchange(Int64, Int64)

Ustawia 64-bitową liczbę całkowitą ze znakiem na określoną wartość i zwraca oryginalną wartość jako operację niepodzielną.Sets a 64-bit signed integer to a specified value and returns the original value, as an atomic operation.

Exchange(IntPtr, IntPtr)

Ustawia dojście lub wskaźnik specyficzny dla platformy do określonej wartości i zwraca oryginalną wartość jako operację niepodzielną.Sets a platform-specific handle or pointer to a specified value and returns the original value, as an atomic operation.

Exchange(Object, Object)

Ustawia obiekt na określoną wartość i zwraca odwołanie do oryginalnego obiektu, jako operację niepodzielną.Sets an object to a specified value and returns a reference to the original object, as an atomic operation.

Exchange(Single, Single)

Ustawia liczbę zmiennoprzecinkową o pojedynczej precyzji na określoną wartość i zwraca oryginalną wartość jako operację niepodzielną.Sets a single-precision floating point number to a specified value and returns the original value, as an atomic operation.

Exchange(UInt32, UInt32)

Ustawia 32-bitową liczbę całkowitą bez znaku na określoną wartość i zwraca oryginalną wartość jako operację niepodzielną.Sets a 32-bit unsigned integer to a specified value and returns the original value, as an atomic operation.

Exchange(UInt64, UInt64)

Ustawia 64-bitową liczbę całkowitą bez znaku na określoną wartość i zwraca oryginalną wartość jako operację niepodzielną.Sets a 64-bit unsigned integer to a specified value and returns the original value, as an atomic operation.

Exchange<T>(T, T)

Ustawia zmienną określonego typu T na określoną wartość i zwraca oryginalną wartość jako operację niepodzielną.Sets a variable of the specified type T to a specified value and returns the original value, as an atomic operation.

Increment(Int32)

Zwiększa określoną zmienną i zapisuje wynik jako operację niepodzielną.Increments a specified variable and stores the result, as an atomic operation.

Increment(Int64)

Zwiększa określoną zmienną i zapisuje wynik jako operację niepodzielną.Increments a specified variable and stores the result, as an atomic operation.

Increment(UInt32)

Zwiększa określoną zmienną i zapisuje wynik jako operację niepodzielną.Increments a specified variable and stores the result, as an atomic operation.

Increment(UInt64)

Zwiększa określoną zmienną i zapisuje wynik jako operację niepodzielną.Increments a specified variable and stores the result, as an atomic operation.

MemoryBarrier()

Synchronizuje dostęp do pamięci w następujący sposób: procesor, który wykonuje bieżący wątek, nie może zmienić kolejności instrukcji w taki sposób, aby pamięć była używana przed wywołaniem do MemoryBarrier() wykonania po uzyskaniu dostępu do pamięci, który następuje po wywołaniu MemoryBarrier() .Synchronizes memory access as follows: The processor that executes the current thread cannot reorder instructions in such a way that memory accesses before the call to MemoryBarrier() execute after memory accesses that follow the call to MemoryBarrier().

MemoryBarrierProcessWide()

Zapewnia barierę pamięci obejmującą cały proces, która zapewnia, że odczyty i zapisy z dowolnego procesora nie mogą być przenoszone między barierami.Provides a process-wide memory barrier that ensures that reads and writes from any CPU cannot move across the barrier.

Or(Int32, Int32)

Bitowe "ORS" 2 32-bitowe liczby całkowite ze znakiem i zamieniają pierwszą liczbę całkowitą z wynikiem, jako operację niepodzielną.Bitwise "ors" two 32-bit signed integers and replaces the first integer with the result, as an atomic operation.

Or(Int64, Int64)

Bitowe "ORS" 2 64-bitowe liczby całkowite ze znakiem i zamieniają pierwszą liczbę całkowitą z wynikiem, jako operację niepodzielną.Bitwise "ors" two 64-bit signed integers and replaces the first integer with the result, as an atomic operation.

Or(UInt32, UInt32)

Bitowe "ORS" 2 32-bitowe liczby całkowite bez znaku i zamieniają pierwszą liczbę całkowitą na wynik jako operację niepodzielną.Bitwise "ors" two 32-bit unsigned integers and replaces the first integer with the result, as an atomic operation.

Or(UInt64, UInt64)

Bitowe "ORS" 2 64-bitowe liczby całkowite bez znaku i zamieniają pierwszą liczbę całkowitą na wynik jako operację niepodzielną.Bitwise "ors" two 64-bit unsigned integers and replaces the first integer with the result, as an atomic operation.

Read(Int64)

Zwraca 64-bitową wartość załadowaną jako operację niepodzielną.Returns a 64-bit value, loaded as an atomic operation.

Read(UInt64)

Zwraca 64-bitową wartość unsigned, która została załadowana jako operacja niepodzielna.Returns a 64-bit unsigned value, loaded as an atomic operation.

SpeculationBarrier()

Definiuje ogranicznik pamięci, który blokuje wykonywanie spekulacyjne od tego momentu do momentu ukończenia operacji odczytu i zapisu.Defines a memory fence that blocks speculative execution past this point until pending reads and writes are complete.

Dotyczy

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkowo.This type is thread safe.

Zobacz też