interlocked

What's the difference between InterlockedCompareExchangeRelease() and InterlockedCompareExchangeAcquire() ? When I try to learn the synchronization functions with WIN32 API, I find there are two functions named differently but seems to do the same thing: LONG __cdecl InterlockedCompareExchangeRelease( __inout LONG volatile *Destination, __in LONG Exchange, __in LONG Comparand ); and LONG __cdecl InterlockedCompareExchangeAcquire( __inout LONG volatile *Destination, __in LONG Exchange, __in LONG Comparand ); I check the MSDN, it says those functions are: Performs an atomic compare-and-exchange

I have a bit of my game which looks like this: public static float Time; float someValue = 123; Interlocked.Exchange(ref Time, someValue); I want to change Time to be a Uint32; however, when I try to use UInt32 instead of float for the values, it protests that the type must be a reference type. Float is not a reference type, so I know it's technically possible to do this with non-reference types. Is there any practical way to make this work with UInt32 ? Although ugly, it is actually possible to perform an atomic Exchange or CompareExchange on an enum or other blittable value type of 64 bits

Is Interlocked.Increment(ref x) faster or slower than x++ for ints and longs on various platforms? It is slower since it forces the action to occur atomically and it acts as a memory barrier, eliminating the processor's ability to re-order memory accesses around the instruction. You should be using Interlocked.Increment when you want the action to be atomic on state that can be shared between threads - it's not intended to be a full replacement for x++. In our experience the InterlockedIncrement() et al on Windows are quite significant impacts. In one sample case we were able to eliminate the

Just checking... _count is being accessed safely, right? Both methods are accessed by multiple threads. private int _count; public void CheckForWork() { if (_count >= MAXIMUM) return; Interlocked.Increment(ref _count); Task t = Task.Run(() => Work()); t.ContinueWith(CompletedWorkHandler); } public void CompletedWorkHandler(Task completedTask) { Interlocked.Decrement(ref _count); // Handle errors, etc... } No, if (_count >= MAXIMUM) return; is not thread safe. edit: You'd have to lock around the read too, which should then logically be grouped with the increment, so I'd rewrite like private int

Asking this question with C# tag, but if it is possible, it should be possible in any language. Is it possible to implement a doubly linked list using Interlocked operations to provide no-wait locking? I would want to insert, add and remove, and clear without waiting. Unknown A simple google search will reveal many lock-free doubly linked list papers. However, they are based on atomic CAS (compare and swap). I don't know how atomic the operations in C# are, but according to this website http://www.albahari.com/threading/part4.aspx C# operations are only guaranteed to be atomic for reading and