blocks|key|1714809|text|除了写入新值之外，InterlockedExchange还读取并返回先前的值；整个操作是原子的。这对lock-free+algorithms很有用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1714810|(顺便说一句，32位写入不能保证是原子的。例如，考虑写入未对齐并跨越高速缓存边界的情况。)|1714811|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Lock-free_and_wait-free_algorithms^0|9|J|1E|K|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

As well as writing the new value, <code>InterlockedExchange</code> also reads and returns the previous value; this whole operation is atomic. This is useful for <a href="http://en.wikipedia.org/wiki/Lock-free_and_wait-free_algorithms" rel="nofollow noreferrer">lock-free algorithms</a>.

(Incidentally, 32-bit writes are not guaranteed to be atomic. Consider the case where the write is unaligned and straddles a cache boundary, for instance.)

blocks|key|1499789|text|设置32位值是原子的，但只有在设置文字的情况下才是这样。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1499790|B=a是2个操作：|1499791|mov+++++++++eax,dword+ptr+[a]+
mov+++++++++dword+ptr+[b],eax+|code-block|syntax|javascript|1499792|从理论上讲，第一次和第二次操作之间可能会有一些中断。|1499793|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Setting a 32-bit value is atomic, but only if you're setting a literal.

b = a is 2 operations:

<pre><code>mov eax,dword ptr [a] 
mov dword ptr [b],eax 
</code></pre>

Theoretically there could be some interruption between the first and second operation.

blocks|key|1714945|text|在多处理器或多核机器中，每个核心都有自己的缓存-因此每个核心都有各自潜在的不同“视图”，即系统内存的内容是什么。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1714946|线程同步机制负责核心之间的同步，有关更多信息，请查看http://blogs.msdn.com/oldnewthing/archive/2008/10/03/8969397.aspx或谷歌的获取和释放语义|offset|length|1714947|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/oldnewthing/archive/2008/10/03/8969397.aspx^0|0|Q|1T|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

In a multi-processor or multi-core machine each core has it's own cache - so each core has each own potentially different "view" of what the content of the system memory is.

Thread synchronization mechanisms take care of synchronizing between cores, for more information look at <a href="http://blogs.msdn.com/oldnewthing/archive/2008/10/03/8969397.aspx" rel="nofollow noreferrer">http://blogs.msdn.com/oldnewthing/archive/2008/10/03/8969397.aspx</a> or google for acquire and release semantics

blocks|key|1715006|text|默认情况下，写入值永远不是原子的。向变量写入值时，会生成几条机器指令。使用现代的抢占式OSes，操作系统可能会在写操作的各个操作之间切换到另一个线程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1715007|这在多处理器机器上更是一个问题，在多处理器机器上，可能有多个线程同时执行，并试图同时写入单个内存位置。|1715008|互锁操作通过使用专门的指令来进行写操作来避免这种情况(x86具有针对这种情况的专用指令)，它在一条指令中执行读取-修改-写入。这些指令还锁定所有处理器的内存总线，以确保没有其他执行线程可以在同一时间写入该值。|1715009|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Writing a value is never atomic by default. When you write a value to a variable, several machine instructions are generated. With modern, preemptive OSes, the OS might switch to another thread between the individual operations of the write.

This is even more a problem on multi-processor machines, where several threads could be executing at the same time, and trying to write to a single memory location simultaneously.

Interlocked operations avoid this by using specialized instructions to make the write (x86 has dedicated instructions for this kind of situation), which do the read-modify-write in one instruction. These instructions also lock the memory bus of all processors, to ensure that no other executing thread could be writing to the value at the same time.

blocks|key|1500068|text|InterlockedExchange确保变量的更改和原始值的返回不会被其他线程中断。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1500069|因此，如果'i‘是一个整数，则这些调用(单独调用)不需要’i‘周围的InterlockedExchange：|1500070|a+=+i;
i+=+9;
i+=+a;
i+=+a+%2B+9;
a+=+i+%2B+9;
if(0+==+i)|code-block|syntax|javascript|1500071|这些语句都不依赖于'i‘的初始值和终值。但以下调用确实需要‘i’周围的InterlockedExchange：|1500072|a+=+i%2B%2B;++//a+=+InterlockedExchange(&i,+i+%2B+1);|1500073|如果没有它，通过相同代码运行的两个线程可能会获得分配给'a‘或'a’的相同值'i‘，可能会意外地跳过两个或更多数字。|1500074|if(0+==+i%2B%2B)+//if(0+==+InterlockedExchange(&i,+i+%2B+1))|1500075|两个线程可能都会执行本应只发生一次的代码。|1500076|等。|1500077|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

InterlockedExchange makes sure that the change of a variable and the return of its original value are not interrupted by other threads.

So, if 'i' is an int, these calls (taken individually) do not need InterlockedExchange around 'i':

<pre><code>a = i;
i = 9;
i = a;
i = a + 9;
a = i + 9;
if(0 == i)
</code></pre>

None of these statements rely upon BOTH the initial AND final values of 'i'. But these following calls DO need InterlockedExchange around 'i':

<pre><code>a = i++; //a = InterlockedExchange(&amp;i, i + 1);
</code></pre>

Without it, two threads running through this same code might get the same value of 'i' assigned to 'a' or 'a' may unexpectedly skip two or more numbers.

<pre><code>if(0 == i++) //if(0 == InterlockedExchange(&amp;i, i + 1))
</code></pre>

Two threads may both execute the code that is only supposed to happen once. 
etc.

I came across the function <a href="http://msdn.microsoft.com/en-us/library/ms683590(VS.85).aspx" rel="noreferrer" title="MSDN Link">InterlockedExchange</a> and was wondering when I should use this function. In my opinion, setting a 32 Bit value on an x86 processor should always be atomic? 
In the case where I want to use the function, the new value does not depend on the old value (it is not an increment operation).
Could you provide an example where this method is mandatory (I'm not looking for InterlockedCompareExchange)

When should the Win32 InterlockedExchange function be used?

我遇到了函数，想知道什么时候应该使用这个函数。在我看来，在x86处理器上设置32位值应该始终是原子的？在我想使用函数的情况下，新值并不依赖于旧值(这不是一个递增操作)。你能提供一个这个方法是强制的例子吗(我不是在找InterlockedCompareExchange)

问什么时候应该使用Win32 InterlockedExchange函数？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候应该使用Win32 InterlockedExchange函数？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候应该使用Win32 InterlockedExchange函数？
EN