# Interlocked.CompareExchangeInterlocked.CompareExchangeInterlocked.CompareExchangeInterlocked.CompareExchange Method

## 重载

 CompareExchange(Double, Double, Double) CompareExchange(Double, Double, Double) CompareExchange(Double, Double, Double) CompareExchange(Double, Double, Double) 比较两个双精度浮点数是否相等，如果相等，则替换第一个值。Compares two double-precision floating point numbers for equality and, if they are equal, replaces the first value. CompareExchange(Int32, Int32, Int32) CompareExchange(Int32, Int32, Int32) CompareExchange(Int32, Int32, Int32) CompareExchange(Int32, Int32, Int32) 比较两个 32 位有符号整数是否相等，如果相等，则替换第一个值。Compares two 32-bit signed integers for equality and, if they are equal, replaces the first value. CompareExchange(Int64, Int64, Int64) CompareExchange(Int64, Int64, Int64) CompareExchange(Int64, Int64, Int64) CompareExchange(Int64, Int64, Int64) 比较两个 64 位有符号整数是否相等，如果相等，则替换第一个值。Compares two 64-bit signed integers for equality and, if they are equal, replaces the first value. CompareExchange(IntPtr, IntPtr, IntPtr) CompareExchange(IntPtr, IntPtr, IntPtr) CompareExchange(IntPtr, IntPtr, IntPtr) CompareExchange(IntPtr, IntPtr, IntPtr) 比较两个平台特定的句柄或指针是否相等，如果相等，则替换第一个。Compares two platform-specific handles or pointers for equality and, if they are equal, replaces the first one. CompareExchange(Object, Object, Object) CompareExchange(Object, Object, Object) CompareExchange(Object, Object, Object) CompareExchange(Object, Object, Object) 比较两个对象是否引用相等，如果相等，则替换第一个对象。Compares two objects for reference equality and, if they are equal, replaces the first object. CompareExchange(Single, Single, Single) CompareExchange(Single, Single, Single) CompareExchange(Single, Single, Single) CompareExchange(Single, Single, Single) 比较两个单精度浮点数是否相等，如果相等，则替换第一个值。Compares two single-precision floating point numbers for equality and, if they are equal, replaces the first value. CompareExchange(T, T, T) CompareExchange(T, T, T) CompareExchange(T, T, T) CompareExchange(T, T, T) 比较指定的引用类型 `T` 的两个实例是否引用相等，如果相等，则替换第一个。Compares two instances of the specified reference type `T` for reference equality and, if they are equal, replaces the first one.

## CompareExchange(Double, Double, Double)CompareExchange(Double, Double, Double)CompareExchange(Double, Double, Double)CompareExchange(Double, Double, Double)

``````public:
static double CompareExchange(double % location1, double value, double comparand);``````
``public static double CompareExchange (ref double location1, double value, double comparand);``
``static member CompareExchange :  * double * double -> double``
``Public Shared Function CompareExchange (ByRef location1 As Double, value As Double, comparand As Double) As Double``

#### 参数

location1
Double Double Double Double

value
Double Double Double Double

comparand
Double Double Double Double

#### 返回

`location1` 中的原始值。The original value in `location1`.

#### 异常

`location1` 的地址为空指针。The address of `location1` is a null pointer.

### 示例

``````// 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
*/
``````
``````' This example demonstrates a thread-safe method that adds to a
' running total.
Imports 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 totalValue As Double = 0.0

' The Total property returns the running total.
Public ReadOnly Property Total As Double
Get
Return totalValue
End Get
End Property

' AddToTotal safely adds a value to the running total.
Public Function AddToTotal(ByVal addend As Double) As Double
Dim initialValue, computedValue As Double
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.
Loop While initialValue <> Interlocked.CompareExchange( _
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
End Function
End Class

Public Class Test
' Create an instance of the ThreadSafe class to test.
Private Shared ts As New ThreadSafe()
Private Shared control As Double

Private Shared r As New Random()
Private Shared mre As New ManualResetEvent(false)

<MTAThread> _
Public Shared Sub Main()
' Create two threads, name them, and start them. The
' threads will block on mre.
Dim t1 As New Thread(AddressOf TestThread)
t1.Name = "Thread 1"
t1.Start()
Dim t2 As New Thread(AddressOf 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)
End Sub

Private Shared Sub TestThread()
' Wait until the signal.
mre.WaitOne()

For i As Integer = 1 to 1000000
' Add to the running total in the ThreadSafe instance, and
' to an ordinary double.
'
Dim testValue As Double = r.NextDouble
control += testValue
ts.AddToTotal(testValue)
Next
End Sub
End Class

' On a dual-processor computer, this code example produces output
' similar to the following:
'
'Thread safe: 998068.049623744  Ordinary Double: 759775.417190589
``````

## CompareExchange(Int32, Int32, Int32)CompareExchange(Int32, Int32, Int32)CompareExchange(Int32, Int32, Int32)CompareExchange(Int32, Int32, Int32)

``````public:
static int CompareExchange(int % location1, int value, int comparand);``````
``public static int CompareExchange (ref int location1, int value, int comparand);``
``static member CompareExchange :  * int * int -> int``
``Public Shared Function CompareExchange (ByRef location1 As Integer, value As Integer, comparand As Integer) As Integer``

#### 参数

location1
Int32 Int32 Int32 Int32

value
Int32 Int32 Int32 Int32

comparand
Int32 Int32 Int32 Int32

#### 返回

`location1` 中的原始值。The original value in `location1`.

#### 异常

`location1` 的地址为空指针。The address of `location1` is a null pointer.

### 示例

.NET Framework Add的2.0 版中引入的方法提供了更方便的方法来累积整数的线程安全运行总计。The Add method, introduced in version 2.0 of the .NET Framework, provides a more convenient way to accumulate thread-safe running totals for integers.

``````// 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.dll>

using namespace System::Threading;
public ref class ThreadSafe
{
private:

// totalValue contains a running total that can be updated
// by multiple threads. It must be protected from unsynchronized
// access.
int totalValue;

public:

property int Total
{

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

}

// AddToTotal safely adds a value to the running total.
int AddToTotal( int addend )
{
int initialValue;
int 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( 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;
}

};

``````
``````// 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;
}
}
``````
``````' 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.
Imports 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 totalValue As Integer = 0

' The Total property returns the running total.
Public ReadOnly Property Total As Integer
Get
Return totalValue
End Get
End Property

' AddToTotal safely adds a value to the running total.
Public Function AddToTotal(ByVal addend As Integer) As Integer
Dim initialValue, computedValue As Integer
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.
Loop While initialValue <> Interlocked.CompareExchange( _
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
End Function
End Class
``````

## CompareExchange(Int64, Int64, Int64)CompareExchange(Int64, Int64, Int64)CompareExchange(Int64, Int64, Int64)CompareExchange(Int64, Int64, Int64)

``````public:
static long CompareExchange(long % location1, long value, long comparand);``````
``public static long CompareExchange (ref long location1, long value, long comparand);``
``static member CompareExchange :  * int64 * int64 -> int64``
``Public Shared Function CompareExchange (ByRef location1 As Long, value As Long, comparand As Long) As Long``

#### 参数

location1
Int64 Int64 Int64 Int64

value
Int64 Int64 Int64 Int64

comparand
Int64 Int64 Int64 Int64

#### 返回

`location1` 中的原始值。The original value in `location1`.

#### 异常

`location1` 的地址为空指针。The address of `location1` is a null pointer.

## CompareExchange(IntPtr, IntPtr, IntPtr)CompareExchange(IntPtr, IntPtr, IntPtr)CompareExchange(IntPtr, IntPtr, IntPtr)CompareExchange(IntPtr, IntPtr, IntPtr)

``````public:
static IntPtr CompareExchange(IntPtr % location1, IntPtr value, IntPtr comparand);``````
``public static IntPtr CompareExchange (ref IntPtr location1, IntPtr value, IntPtr comparand);``
``static member CompareExchange :  * nativeint * nativeint -> nativeint``
``Public Shared Function CompareExchange (ByRef location1 As IntPtr, value As IntPtr, comparand As IntPtr) As IntPtr``

#### 参数

location1
IntPtr IntPtr IntPtr IntPtr

value
IntPtr IntPtr IntPtr IntPtr

comparand
IntPtr IntPtr IntPtr IntPtr

#### 返回

`location1` 中的原始值。The original value in `location1`.

#### 异常

`location1` 的地址为空指针。The address of `location1` is a null pointer.

### 注解

IntPtr是特定于平台的类型。IntPtr is a platform-specific type.

## CompareExchange(Object, Object, Object)CompareExchange(Object, Object, Object)CompareExchange(Object, Object, Object)CompareExchange(Object, Object, Object)

``````public:
static System::Object ^ CompareExchange(System::Object ^ % location1, System::Object ^ value, System::Object ^ comparand);``````
``public static object CompareExchange (ref object location1, object value, object comparand);``
``static member CompareExchange :  * obj * obj -> obj``
``Public Shared Function CompareExchange (ByRef location1 As Object, value As Object, comparand As Object) As Object``

#### 参数

location1
Object Object Object Object

value
Object Object Object Object

comparand
Object Object Object Object

#### 返回

`location1` 中的原始值。The original value in `location1`.

#### 异常

`location1` 的地址为空指针。The address of `location1` is a null pointer.

## CompareExchange(Single, Single, Single)CompareExchange(Single, Single, Single)CompareExchange(Single, Single, Single)CompareExchange(Single, Single, Single)

``````public:
static float CompareExchange(float % location1, float value, float comparand);``````
``public static float CompareExchange (ref float location1, float value, float comparand);``
``static member CompareExchange :  * single * single -> single``
``Public Shared Function CompareExchange (ByRef location1 As Single, value As Single, comparand As Single) As Single``

#### 参数

location1
Single Single Single Single

value
Single Single Single Single

comparand
Single Single Single Single

#### 返回

`location1` 中的原始值。The original value in `location1`.

#### 异常

`location1` 的地址为空指针。The address of `location1` is a null pointer.

### 示例

``````// 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
*/
``````
``````' This example demonstrates a thread-safe method that adds to a
' running total.
Imports 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 totalValue As Single = 0.0

' The Total property returns the running total.
Public ReadOnly Property Total As Single
Get
Return totalValue
End Get
End Property

' AddToTotal safely adds a value to the running total.
Public Function AddToTotal(ByVal addend As Single) As Single
Dim initialValue, computedValue As Single
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.
Loop While initialValue <> Interlocked.CompareExchange( _
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
End Function
End Class

Public Class Test
' Create an instance of the ThreadSafe class to test.
Private Shared ts As New ThreadSafe()
Private Shared control As Single

Private Shared r As New Random()
Private Shared mre As New ManualResetEvent(false)

<MTAThread> _
Public Shared Sub Main()
' Create two threads, name them, and start them. The
' threads will block on mre.
Dim t1 As New Thread(AddressOf TestThread)
t1.Name = "Thread 1"
t1.Start()
Dim t2 As New Thread(AddressOf 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 Single: {1}", ts.Total, control)
End Sub

Private Shared Sub TestThread()
' Wait until the signal.
mre.WaitOne()

For i As Integer = 1 to 1000000
' Add to the running total in the ThreadSafe instance, and
' to an ordinary Single.
'
Dim testValue As Single = r.NextDouble()
control += testValue
ts.AddToTotal(testValue)
Next
End Sub
End Class

' On a dual-processor computer, this code example produces output
' similar to the following:
'
'Thread safe: 17039.57  Ordinary Single: 15706.44
``````

## CompareExchange<T>(T, T, T)CompareExchange<T>(T, T, T)CompareExchange<T>(T, T, T)CompareExchange<T>(T, T, T)

``````public:
generic <typename T>
where T : class static T CompareExchange(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;``````
``static member CompareExchange :  * 'T * 'T -> 'T (requires 'T : null)``
``Public Shared Function CompareExchange(Of T As Class) (ByRef location1 As T, value As T, comparand As T) As T``

T

location1
T T T T

value
T T T T

comparand
T T T T

#### 返回

T T T T

`location1` 中的原始值。The original value in `location1`.

#### 异常

`location1` 的地址为空指针。The address of `location1` is a null pointer.