Interlocked.CompareExchange Метод

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.cs

[System.CLSCompliant(false)]
public static UIntPtr CompareExchange(ref UIntPtr location1, UIntPtr value, UIntPtr comparand);

Параметры

Возвращаемое значение

Исходное значение в location1.

Атрибуты

CLSCompliantAttribute

Исключения

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.cs

[System.CLSCompliant(false)]
public static ulong CompareExchange(ref ulong location1, ulong value, ulong comparand);

Параметры

Возвращаемое значение

Исходное значение в location1.

Атрибуты

CLSCompliantAttribute

Исключения

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.cs

[System.CLSCompliant(false)]
public static uint CompareExchange(ref uint location1, uint value, uint comparand);

Параметры

Возвращаемое значение

Исходное значение в location1.

Атрибуты

CLSCompliantAttribute

Исключения

[System.CLSCompliant(false)]
public static ushort CompareExchange(ref ushort location1, ushort value, ushort comparand);

Параметры

Возвращаемое значение

Исходное значение в location1.

Атрибуты

CLSCompliantAttribute

Исключения

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.cs

public static float CompareExchange(ref float location1, float value, float comparand);

Параметры

Возвращаемое значение

Исходное значение в location1.

Исключения

Примеры

В следующем примере кода демонстрируется потокобезопасный метод, который накапливает в общей сложности Single значений. Два потока добавляют ряд значений Single с помощью метода, безопасного для потоков и обычного добавления, и когда потоки завершают итоги, сравниваются. На компьютере с двумя процессорами имеется значительное различие в итогах.

В потокобезопасном методе сохраняется начальное значение запущенного итогового значения, а затем используется метод CompareExchange для обмена только что вычисляемой суммой со старым итогом. Если возвращаемое значение не равно сохраненному значению запущенного итогового значения, то другой поток обновил итог в то же время. В этом случае необходимо повторить попытку обновить запущенный итог.

// This example demonstrates a thread-safe method that adds to a
// running total.  
using System;
using System.Threading;

public class ThreadSafe
{
    // Field totalValue contains a running total that can be updated
    // by multiple threads. It must be protected from unsynchronized 
    // access.
    private float totalValue = 0.0F;

    // The Total property returns the running total.
    public float Total { get { return totalValue; }}

    // AddToTotal safely adds a value to the running total.
    public float AddToTotal(float addend)
    {
        float initialValue, computedValue;
        do
        {
            // Save the current running total in a local variable.
            initialValue = totalValue;

            // Add the new value to the running total.
            computedValue = initialValue + addend;

            // CompareExchange compares totalValue to initialValue. If
            // they are not equal, then another thread has updated the
            // running total since this loop started. CompareExchange
            // does not update totalValue. CompareExchange returns the
            // contents of totalValue, which do not equal initialValue,
            // so the loop executes again.
        }
        while (initialValue != Interlocked.CompareExchange(ref totalValue, 
            computedValue, initialValue));
        // If no other thread updated the running total, then 
        // totalValue and initialValue are equal when CompareExchange
        // compares them, and computedValue is stored in totalValue.
        // CompareExchange returns the value that was in totalValue
        // before the update, which is equal to initialValue, so the 
        // loop ends.

        // The function returns computedValue, not totalValue, because
        // totalValue could be changed by another thread between
        // the time the loop ends and the function returns.
        return computedValue;
    }
}

public class Test
{
    // Create an instance of the ThreadSafe class to test.
    private static ThreadSafe ts = new ThreadSafe();
    private static float control;

    private static Random r = new Random();
    private static ManualResetEvent mre = new ManualResetEvent(false);

    public static void Main()
    {
        // Create two threads, name them, and start them. The
        // thread will block on mre.
        Thread t1 = new Thread(TestThread);
        t1.Name = "Thread 1";
        t1.Start();
        Thread t2 = new Thread(TestThread);
        t2.Name = "Thread 2";
        t2.Start();

        // Now let the threads begin adding random numbers to 
        // the total.
        mre.Set();
        
        // Wait until all the threads are done.
        t1.Join();
        t2.Join();

        Console.WriteLine("Thread safe: {0}  Ordinary float: {1}", 
            ts.Total, control);
    }

    private static void TestThread()
    {
        // Wait until the signal.
        mre.WaitOne();

        for(int i = 1; i <= 1000000; i++)
        {
            // Add to the running total in the ThreadSafe instance, and
            // to an ordinary float.
            //
            float testValue = (float) r.NextDouble();
            control += testValue;
            ts.AddToTotal(testValue);
        }
    }
}

/* On a dual-processor computer, this code example produces output 
   similar to the following:

Thread safe: 17039.57  Ordinary float: 15706.44
 */

Комментарии

Если comparand и значение в location1 равны, value хранится в location1. В противном случае операция не выполняется. Операции сравнения и обмена выполняются как атомарная операция. Возвращаемое значение CompareExchange является исходным значением в location1, независимо от того, выполняется ли обмен.

См. также раздел

• управляемых потоков
• Обзор примитивов синхронизации

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.CoreCLR.cs

public static object CompareExchange(ref object location1, object value, object comparand);

public static object? CompareExchange(ref object? location1, object? value, object? comparand);

Параметры

Возвращаемое значение

Исходное значение в location1.

Исключения

Комментарии

Если comparand и объект в location1 равны по ссылке, value хранится в location1. В противном случае операция не выполняется. Операции сравнения и обмена выполняются как атомарная операция. Возвращаемое значение CompareExchange является исходным значением в location1, независимо от того, выполняется ли обмен.

См. также раздел

• управляемых потоков
• Обзор примитивов синхронизации

[System.CLSCompliant(false)]
public static sbyte CompareExchange(ref sbyte location1, sbyte value, sbyte comparand);

Параметры

Возвращаемое значение

Исходное значение в location1.

Атрибуты

CLSCompliantAttribute

Исключения

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.CoreCLR.cs

public static long CompareExchange(ref long location1, long value, long comparand);

Параметры

Возвращаемое значение

Исходное значение в location1.

Исключения

Комментарии

Если comparand и значение в location1 равны, value хранится в location1. В противном случае операция не выполняется. Операции сравнения и обмена выполняются как атомарная операция. Возвращаемое значение CompareExchange является исходным значением в location1, независимо от того, выполняется ли обмен.

См. также раздел

• управляемых потоков
• Обзор примитивов синхронизации

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.CoreCLR.cs

public static int CompareExchange(ref int location1, int value, int comparand);

Параметры

Возвращаемое значение

Исходное значение в location1.

Исключения

Примеры

В следующем примере кода демонстрируется потокобезопасный метод, который накапливает запущенный итог. Начальное значение запущенного итогового значения сохраняется, а затем используется метод CompareExchange для обмена только что вычисляемой суммой со старым итогом. Если возвращаемое значение не равно сохраненному значению запущенного итогового значения, то другой поток обновил итог в то же время. В этом случае необходимо повторить попытку обновить запущенный итог.

// This example demonstrates a thread-safe method that adds to a
// running total.  It cannot be run directly.  You can compile it
// as a library, or add the class to a project.
using System.Threading;

public class ThreadSafe {
    // totalValue contains a running total that can be updated
    // by multiple threads. It must be protected from unsynchronized 
    // access.
    private int totalValue = 0;

    // The Total property returns the running total.
    public int Total {
        get { return totalValue; }
    }

    // AddToTotal safely adds a value to the running total.
    public int AddToTotal(int addend) {
        int initialValue, computedValue;
        do {
            // Save the current running total in a local variable.
            initialValue = totalValue;

            // Add the new value to the running total.
            computedValue = initialValue + addend;

            // CompareExchange compares totalValue to initialValue. If
            // they are not equal, then another thread has updated the
            // running total since this loop started. CompareExchange
            // does not update totalValue. CompareExchange returns the
            // contents of totalValue, which do not equal initialValue,
            // so the loop executes again.
        } while (initialValue != Interlocked.CompareExchange(
            ref totalValue, computedValue, initialValue));
        // If no other thread updated the running total, then 
        // totalValue and initialValue are equal when CompareExchange
        // compares them, and computedValue is stored in totalValue.
        // CompareExchange returns the value that was in totalValue
        // before the update, which is equal to initialValue, so the 
        // loop ends.

        // The function returns computedValue, not totalValue, because
        // totalValue could be changed by another thread between
        // the time the loop ends and the function returns.
        return computedValue;
    }
}

Комментарии

Если comparand и значение в location1 равны, value хранится в location1. В противном случае операция не выполняется. Операции сравнения и обмена выполняются как атомарная операция. Возвращаемое значение CompareExchange является исходным значением в location1, независимо от того, выполняется ли обмен.

См. также раздел

• управляемых потоков
• Обзор примитивов синхронизации

public static short CompareExchange(ref short location1, short value, short comparand);

Параметры

Возвращаемое значение

Исходное значение в location1.

Исключения

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.cs

public static double CompareExchange(ref double location1, double value, double comparand);

Параметры

Возвращаемое значение

Исходное значение в location1.

Исключения

Примеры

В следующем примере кода демонстрируется потокобезопасный метод, который накапливает в общей сложности Double значений. Два потока добавляют ряд значений Double с помощью метода, безопасного для потоков и обычного добавления, и когда потоки завершают итоги, сравниваются. На компьютере с двумя процессорами имеется значительное различие в итогах.

В потокобезопасном методе сохраняется начальное значение запущенного итогового значения, а затем используется метод CompareExchange для обмена только что вычисляемой суммой со старым итогом. Если возвращаемое значение не равно сохраненному значению запущенного итогового значения, то другой поток обновил итог в то же время. В этом случае необходимо повторить попытку обновить запущенный итог.

// This example demonstrates a thread-safe method that adds to a
// running total.  
using System;
using System.Threading;

public class ThreadSafe
{
    // Field totalValue contains a running total that can be updated
    // by multiple threads. It must be protected from unsynchronized 
    // access.
    private double totalValue = 0.0;

    // The Total property returns the running total.
    public double Total { get { return totalValue; }}

    // AddToTotal safely adds a value to the running total.
    public double AddToTotal(double addend)
    {
        double initialValue, computedValue;
        do
        {
            // Save the current running total in a local variable.
            initialValue = totalValue;

            // Add the new value to the running total.
            computedValue = initialValue + addend;

            // CompareExchange compares totalValue to initialValue. If
            // they are not equal, then another thread has updated the
            // running total since this loop started. CompareExchange
            // does not update totalValue. CompareExchange returns the
            // contents of totalValue, which do not equal initialValue,
            // so the loop executes again.
        }
        while (initialValue != Interlocked.CompareExchange(ref totalValue, 
            computedValue, initialValue));
        // If no other thread updated the running total, then 
        // totalValue and initialValue are equal when CompareExchange
        // compares them, and computedValue is stored in totalValue.
        // CompareExchange returns the value that was in totalValue
        // before the update, which is equal to initialValue, so the 
        // loop ends.

        // The function returns computedValue, not totalValue, because
        // totalValue could be changed by another thread between
        // the time the loop ends and the function returns.
        return computedValue;
    }
}

public class Test
{
    // Create an instance of the ThreadSafe class to test.
    private static ThreadSafe ts = new ThreadSafe();
    private static double control;

    private static Random r = new Random();
    private static ManualResetEvent mre = new ManualResetEvent(false);

    public static void Main()
    {
        // Create two threads, name them, and start them. The
        // thread will block on mre.
        Thread t1 = new Thread(TestThread);
        t1.Name = "Thread 1";
        t1.Start();
        Thread t2 = new Thread(TestThread);
        t2.Name = "Thread 2";
        t2.Start();

        // Now let the threads begin adding random numbers to 
        // the total.
        mre.Set();
        
        // Wait until all the threads are done.
        t1.Join();
        t2.Join();

        Console.WriteLine("Thread safe: {0}  Ordinary Double: {1}", 
            ts.Total, control);
    }

    private static void TestThread()
    {
        // Wait until the signal.
        mre.WaitOne();

        for(int i = 1; i <= 1000000; i++)
        {
            // Add to the running total in the ThreadSafe instance, and
            // to an ordinary double.
            //
            double testValue = r.NextDouble();
            control += testValue;
            ts.AddToTotal(testValue);
        }
    }
}

/* On a dual-processor computer, this code example produces output 
   similar to the following:

Thread safe: 998068.049623744  Ordinary Double: 759775.417190589
 */

Комментарии

Если comparand и значение в location1 равны, value хранится в location1. В противном случае операция не выполняется. Операции сравнения и обмена выполняются как атомарная операция. Возвращаемое значение CompareExchange является исходным значением в location1, независимо от того, выполняется ли обмен.

См. также раздел

• управляемых потоков
• Обзор примитивов синхронизации

public static byte CompareExchange(ref byte location1, byte value, byte comparand);

Параметры

Возвращаемое значение

Исходное значение в location1.

Исключения

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.cs

Исходный код:

Interlocked.cs

public static IntPtr CompareExchange(ref IntPtr location1, IntPtr value, IntPtr comparand);

Параметры

Возвращаемое значение

Исходное значение в location1.

Исключения

Комментарии

Если comparand и значение в location1 равны, value хранится в location1. В противном случае операция не выполняется. Операции сравнения и обмена выполняются как атомарная операция. Возвращаемое значение этого метода является исходным значением в location1, независимо от того, происходит ли обмен.

См. также раздел

• управляемых потоков
• Обзор примитивов синхронизации

Исходный код:

Interlocked.CoreCLR.cs

Исходный код:

Interlocked.CoreCLR.cs

Исходный код:

Interlocked.CoreCLR.cs

public static T CompareExchange<T>(ref T location1, T value, T comparand) where T : class;

public static T CompareExchange<T>(ref T location1, T value, T comparand);

[System.Runtime.InteropServices.ComVisible(false)]
public static T CompareExchange<T>(ref T location1, T value, T comparand) where T : class;

Параметры типа

Параметры

Возвращаемое значение

Исходное значение в location1.

Атрибуты

ComVisibleAttribute

Исключения

Комментарии

Если comparand и значение в location1 равны по ссылке, value хранится в location1. В противном случае операция не выполняется. Сравнение и обмен выполняются как атомарная операция. Возвращаемое значение этого метода является исходным значением в location1, независимо от того, происходит ли обмен.

Этот метод поддерживает только ссылочные типы. Существуют перегрузки метода CompareExchange для типов значений Int32, Int64, IntPtr, Singleи Double, но нет поддержки других типов значений.