blocks|key|3103765|text|实现这一点的正常方法是使用比较交换操作(例如InterlockedCompareExchange64)，其中两个值相同。出于某些原因，我怀疑这可能比添加0更有效，但我没有证据支持这一点。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3103766|有趣的是，.NET的Interlocked类直到.NET+2.0才获得Read方法。我相信Interlocked.Read是使用Interlocked.CompareExchange实现的。(请注意，Interlocked.Read的文档给我带来了一些误导-它讨论了原子性，但没有讨论波动性，这意味着在.NET上有一些非常具体的东西。如果有的话，我不确定Win32内存模型如何保证来自不同线程的新编写的值的可见性。)|3103767|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.threading.interlocked.aspx|1|http://msdn.microsoft.com/en-us/library/system.threading.interlocked.read.aspx^0|M|S|0|A|B|Z|4|19|G|1S|R|2S|G|A|B|0|Z|4|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]|$9|18|A|19|1|1A]]|E|$]]|$1|H|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]]]

The normal way of implementing this is to use a compare-exchange operation (e.g. <code>InterlockedCompareExchange64</code>) where both values are the same. I have a sneaking suspicion this can be performed more efficiently than an add of 0 for some reason, but I have no evidence to back this up.

Interestingly, .NET's <a href="http://msdn.microsoft.com/en-us/library/system.threading.interlocked.aspx" rel="noreferrer"><code>Interlocked</code></a> class didn't gain a <a href="http://msdn.microsoft.com/en-us/library/system.threading.interlocked.read.aspx" rel="noreferrer"><code>Read</code></a> method until .NET 2.0. I believe that <code>Interlocked.Read</code> is implemented using <code>Interlocked.CompareExchange</code>. (Note that the documentation for <code>Interlocked.Read</code> strikes me as somewhat misleading - it talks about atomicity, but not volatility, which means something very specific on .NET. I'm not sure what the Win32 memory model guarantees about visibility of newly written values from a different thread, if anything.)

blocks|key|3103777|text|我认为你对“不同步”的解释是错误的。简单的读取是原子的，但您必须自己处理重新排序和内存可见性问题。前者是通过在适当的位置使用围栏指令来处理的，后者是读取的非问题(但潜在的并发写入必须确保适当的可见性，如果互锁函数映射到锁定的asm指令，则应该这样做)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3103778|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I think that your interpretation of "not synchronized" is wrong. Simple reads are atomic, but you have to take care of reordering and memory visibility issues yourself. The former is handled by using fence instructions at appropriate places, the latter is a non-issue with read (but a potential concurrent write has to ensure proper visibility, which Interlocked functions should do if they map to LOCKED asm instructions).

blocks|key|340480|text|整个讨论的关键是正确的对齐，这在xxx的分区I中的“12.6.2+Alignment”一节中进行了设计：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|340481|Built-in+datatypes+shall+be+properly+aligned,+which+is+defined+as+follows:
•+1-byte,+2-byte,+and+4-byte+data+is+properly+aligned+when+it+is+stored+at
++a+1-byte,+2-byte,+or+4-byte+boundary,+respectively.
•+8-byte+data+is+properly+aligned+when+it+is+stored+on+the+same+boundary
++required+by+the+underlying+hardware+for+atomic+access+to+a+native+int.|code-block|syntax|javascript|340482|基本上，所有32位的值都具有所需的对齐方式，在64位平台上，64位的值也具有所需的对齐方式。|340483|但是请注意:有一些属性可以显式地更改内存中类的布局，这可能会导致您失去这种对齐方式。这些都是特定于此目的的属性，因此，除非您已着手更改布局，否则这不应适用于您。|340484|在这种情况下，Interlocked类的目的是提供只能在“之前”或“之后”状态下观察到的操作。互锁操作通常只在修改内存时才被关注(通常是以一些非平凡的比较-交换类型的方式)。正如您找到的MSDN文章所指出的那样，读操作(如果正确对齐)可以在任何时候被视为原子操作，而无需采取进一步的预防措施。|340485|但是，在处理读取操作时还有其他注意事项：|340486|340487|在现代CPU上，尽管读取可能是原子的，但它也可能从某个地方的陈旧缓存返回错误的值……如果你在32位硬件上处理64位的值，你可能需要使用Interlocked.Read操作来保证在单个原子操作中读取整个64位的值(否则它可能会作为两次独立的32位读取执行，这两次读取可以从内存update)|unordered-list-item|340488|Re-ordering的任何一侧读取/写入可能导致你得不到预期的值；在这种情况下，可能需要一些内存屏障(显式或通过使用Interlocked类操作)|340489|340490|简短摘要；就原子性而言，很可能您正在做的事情不需要任何特殊的指令来读取...然而，可能还有其他事情你需要小心，这取决于你到底在做什么。|BOLD|340491|entityMap^0|Q|G|0|0|0|0|7|B|0|0|0|1V|G|0|1N|B|0|0|0|4|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|19|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1D|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]|$1|T|3|U|5|V|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|W|3|X|5|V|7|1I|8|@$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]|$1|Z|3|10|5|6|7|1M|8|@$9|1N|A|1O|B|11]]|D|@]|E|$]]|$1|12|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]]|13|$]]

The crux of this whole discussion is proper alignment, which is devined in Partition I of xxx, in section '<code>12.6.2 Alignment</code>':

<pre><code>Built-in datatypes shall be properly aligned, which is defined as follows:
• 1-byte, 2-byte, and 4-byte data is properly aligned when it is stored at
 a 1-byte, 2-byte, or 4-byte boundary, respectively.
• 8-byte data is properly aligned when it is stored on the same boundary
 required by the underlying hardware for atomic access to a native int.
</code></pre>

Basically, all 32-bit values have the required alignment, and on a 64-bit platform, 64-bit values also have the required alignment.

Note though: There are attributes to explicitly alter the layout of classes in memory, which may cause you to lose this alignment. These are attributes specificially for this purpose though, so unless you have set out to alter the layout, this should not apply to you.

With that out of the way, the purpose of the <code>Interlocked</code> class is to provide operations that (to paraphrase) can only be observed in their 'before' or 'after' state. Interlocked operations are normally only of concern when modifying memory (typically in some non-trivial compare-exchange type way). As the MSDN article you found indicates, read operations (when properly aligned) can be considered atomic at all times without further precautions.

There are however other considerations when dealing with read operations:

<ul>
<li>On modern CPUs, although the read may be atomic, it also may return the wrong value from a stale cache somewhere... this is where you may need to make the field 'volatile' to get the behaviour you expect</li>
<li>If you are dealing with a 64-bit value on 32-bit hardware, you may need to use the <code>Interlocked.Read</code> operation to guarantee the whole 64-bit value is read in a single atomic operation (otherwise it may be performed as 2 separate 32-bit reads which can be from either side of a memory update)</li>
<li>Re-ordering of your reads / writes may cause you to not get the value you expected; in which case some memory barrier may be needed (either explicit, or through the use of the <code>Interlocked</code> class operations)</li>
</ul>

Short summary; as far as atomicity goes, it is very likely that what you are doing does not need any special instruction for the read... there may however be other things you need to be careful of, depending on what exactly you are doing.

Win32 api has a set of InterlockedXXX functions to atomically and synchronously manipulate simple variables, however there doesn't seem to be any InterlockedRead function, to simply retrive the value of the variable. How come?

<a href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms684122(v=vs.85).aspx" rel="nofollow noreferrer">MSDN says</a> that:

<blockquote>
 Simple reads and writes to properly-aligned 32-bit variables are atomic operations
</blockquote>

but adds:

<blockquote>
 However, access is not guaranteed to be synchronized. If two threads are reading and writing from the same variable, you cannot determine if one thread will perform its read operation before the other performs its write operation.
</blockquote>

Which means, as I understand it, that a simple read operation of a variable can take place while another, say, InterlockedAdd operation is in place. So why isn't there an interlocked function to read a variable?

I guess the value can be read as the result InterlockedAdd-ing zero, but that doesn't seem the right way to go.

Where is InterlockedRead?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

Win32应用程序接口有一组InterlockedXXX函数来原子地同步操作简单的变量，但是似乎没有任何InterlockedRead函数来简单地检索变量的值。怎么会这样?表示：对正确对齐的32位变量的简单读写都是原子操作但补充说：但是，不能保证访问是同步的。如果两个线程从同一个变量读取和写入，则无法确定其中一个线程是...

问InterlockedRead在哪？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问InterlockedRead在哪？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问InterlockedRead在哪？
EN