blocks|key|3000170|text|不，它不是。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3000171|您提出的分析是非常正确的-+%2B%2B+(和--)运算符如果没有与适当的锁定语义一起使用，就容易受到竞争条件的影响。|offset|length|style|CODE|3000172|这些都很难正确处理，但值得庆幸的是，BCL为这些特定情况提供了现成的解决方案：|3000173|如果你想要原子增量操作，你应该使用Interlocked.Increment。在Interlocked类上还定义了一个Decrement和其他几个有用的原子操作。|3000174|3000175|递增指定的变量并将结果存储为原子操作。|blockquote|3000176|3000177|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/9z791w8a.aspx|1|http://msdn.microsoft.com/en-us/library/5kczs5b5.aspx|2|http://msdn.microsoft.com/en-us/library/7afy2c6y.aspx^0|0|E|2|J|2|0|0|H|L|14|B|1N|9|H|L|0|14|B|1|1N|9|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@$D|14|E|15|F|G]|$D|16|E|17|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|18|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|19|8|@$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]|$D|1E|E|1F|F|G]]|9|@$D|1G|E|1H|1|1I]|$D|1J|E|1K|1|1L]|$D|1M|E|1N|1|1O]]|A|$]]|$1|L|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|1Q|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]|Y|$5|T|U|V|A|$W|Z]]|10|$5|T|U|V|A|$W|11]]]]

No, it isn't.

The analysis you have come up with is quite correct - the <code>++</code> (and <code>--</code>) operators are vulnerable to race conditions if they are not used with appropriate locking semantics.

These are difficult to get right, but thankfully, the BCL has a ready made solution for these specific cases:

You should use <a href="http://msdn.microsoft.com/en-us/library/9z791w8a.aspx" rel="noreferrer"><code>Interlocked.Increment</code></a> if you want an atomic increment operation. There is also a <a href="http://msdn.microsoft.com/en-us/library/7afy2c6y.aspx" rel="noreferrer"><code>Decrement</code></a> and several other useful atomic operations defined on the <a href="http://msdn.microsoft.com/en-us/library/5kczs5b5.aspx" rel="noreferrer"><code>Interlocked</code></a> class.

<blockquote>
 Increments a specified variable and stores the result, as an atomic operation.
</blockquote>

blocks|key|283375|text|不，i%2B%2B看起来很紧凑，但它实际上只是i+=+i+%2B+1的简写，在这种形式下，更容易看出它涉及到对“i”的读取和写入。如果不加锁，它就不是线程安全的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|283376|其他2个参数是：|283377|没有定义为thread-safe|283378|the+Interlocked.Increment+(ref+int+x)|unordered-list-item|283379|
的|283380|`%2B%2B|283381|283382|线程安全是罕见的和昂贵的，当它可用时，它将被清楚地宣传。|283383|entityMap^0|2|3|J|9|0|0|0|4|X|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|11|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|15|8|@]|D|@]|E|$]]|$1|O|3|P|5|L|7|16|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|17|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|18|8|@]|D|@]|E|$]]|$1|T|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|U|$]]

No, <code>i++</code> looks compact but it really is just shorthand for <code>i = i + 1</code> and in that form it is easier to see that it involves a read and a write of 'i'. Without locking it is simply not thread-safe.

2 other arguments are :

<ul>
<li>`++' is not defined as thread-safe</li>
<li>the existence of <code>Interlocked.Increment (ref int x)</code></li>
</ul>

Thread-safety is rare and expensive, it will be clearly advertised when available.

blocks|key|3213575|text|正如其他答案所指出的，不，%2B%2B不是“线程安全”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3213576|我认为在你学习多线程及其危害时会有所帮助的是，开始非常精确地理解你所说的"threadsafe“是什么意思，因为不同的人对它的意思是不同的。本质上，您在这里关心的线程安全方面是操作是否是原子的。“原子”操作是指当被另一个线程中断时，保证不会中途完成的操作。|3213577|(还有许多与原子性无关的其他线程问题，但可能仍然属于某些人对线程安全的定义。例如，假设两个线程分别改变一个变量，而两个线程分别读取该变量，那么这两个读取器能否保证在其他两个线程进行改变的顺序上达成一致？如果您的逻辑依赖于此，那么即使每次读写都是原子的，您也要处理一个非常困难的线程安全问题。)|3213578|在C#中，实际上不能保证任何东西都是原子的。简要地说：|3213579|3213580|读取32位整数或浮点数|unordered-list-item|3213581|读取reference|3213582|writing+32位整数或浮点数|3213583|写入引用|3213584|3213585|保证是原子的(有关详细信息，请参阅规范)。|3213586|特别是，不能保证读取和写入64位整数或浮点数是原子的。如果你说：|3213587|C.x+=+0xDEADBEEF00000000;|code-block|syntax|javascript|3213588|在一个线程上，并且|3213589|C.x+=+0x000000000BADF00D;|3213590|在另一个线程上，则可以在第三个线程上：|3213591|Console.WriteLine(C.x);|3213592|将其写为0xDEADBEEF0BADF00D，即使逻辑上该变量从未保存该值。C#语言保留将长整型的写操作等同于一个接一个地写两个it的权利，在实践中有些芯片确实是这样实现的。在第一次写入之后的线程切换可能会导致读取器读取一些意外的内容。|3213593|它的长处和短处是:在没有锁定任何东西的情况下，不要在两个线程之间共享任何东西。锁只有在满足的情况下才会变慢；如果您因为争用锁而出现性能问题，那么修复导致争用锁的任何体系结构缺陷。如果锁没有争用，并且仍然太慢，那么只有在那时，您才应该考虑使用危险的低锁技术。|3213594|这里使用的常见低锁技术当然是调用Threading.Interlocked.Increment，它以一种保证是原子的方式递增整数。(但是请注意，它仍然不能保证如果两个线程分别在不同的时间执行两个不同变量的互锁增量，而其他线程正在尝试确定哪个增量“最先”发生。C#不能保证所有线程都能看到单个一致的事件排序。)|offset|length|style|CODE|3213595|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|G|V|0^^$0|@$1|2|3|4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1O|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|1Q|8|@]|9|@]|A|$]]|$1|L|3|M|5|K|7|1R|8|@]|9|@]|A|$]]|$1|N|3|O|5|K|7|1S|8|@]|9|@]|A|$]]|$1|P|3|Q|5|K|7|1T|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1V|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1W|8|@]|9|@]|A|$]]|$1|W|3|X|5|Y|7|1X|8|@]|9|@]|A|$Z|10]]|$1|11|3|12|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|13|3|14|5|Y|7|1Z|8|@]|9|@]|A|$Z|10]]|$1|15|3|16|5|6|7|20|8|@]|9|@]|A|$]]|$1|17|3|18|5|Y|7|21|8|@]|9|@]|A|$Z|10]]|$1|19|3|1A|5|6|7|22|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|23|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|24|8|@$1F|25|1G|26|1H|1I]]|9|@]|A|$]]|$1|1J|3|-4|5|6|7|27|8|@]|9|@]|A|$]]]|1K|$]]

As other answers have pointed out, no, ++ is not "threadsafe". 

Something that I think will help as you learn about multithreading and its hazards is to start being very precise about what you mean by "threadsafe", because different people mean different things by it. Essentially the aspect of thread safety you are concerned about here is whether the operation is atomic or not. An "atomic" operation is one which is guaranteed to not be halfway complete when it is interrupted by another thread. 

(There are plenty of other threading problems that have nothing to do with atomicity but which may still fall under some people's definitions of thread safety. For example, given two threads each mutating a variable, and two threads each reading the variable, are the two readers guaranteed to agree on the order in which the other two threads made mutations? If your logic depends on that, then you have a very difficult thread safety problem to deal with even if every read and write is atomic.)

In C#, practically nothing is guaranteed to be atomic. Briefly:

<ul>
<li>reading a 32 bit integer or float</li>
<li>reading a reference</li>
<li>writing a 32 bit integer or float</li>
<li>writing a reference</li>
</ul>

are guaranteed to be atomic (see the specification for the exact details.) 

In particular, reading and writing a 64 bit integer or float is not guaranteed to be atomic. If you say:

<pre><code>C.x = 0xDEADBEEF00000000;
</code></pre>

on one thread, and

<pre><code>C.x = 0x000000000BADF00D;
</code></pre>

on another thread, then it is possible to on a third thread:

<pre><code>Console.WriteLine(C.x);
</code></pre>

have that write out 0xDEADBEEF0BADF00D, even though logically the variable never held that value. The C# language reserves the right to make writing to a long equivalent to writing to two ints, one after the other, and in practice some chips do implement it that way. A thread switch after the first of the writes can cause a reader to read something unexpected.

The long and short of it is: do not share anything between two threads without locking something. Locks are only slow when they are contented; if you have a performance problem because of contended locks then fix whatever architectural flaw is leading to contended locks. If the locks are not contended and are still too slow, only then should you consider going to dangerous low-lock techniques.

The common low-lock technique to use here is of course to call <code>Threading.Interlocked.Increment</code>, which does an increment of an integer in a manner guaranteed to be atomic. (Note however that it still does not make guarantees about things like what happens if two threads are each doing interlocked increments of two different variables at different times, and other threads are trying to determine which increment happened "first". C# does not guarantee that a single consistent ordering of events is seen by all threads.)

NOTE: I am really not very good at Multithreaded programming, but my current project has me doing it so I am trying to get my head around what is thread safe and what is not.

I was reading one of Eric Lippert's <a href="https://stackoverflow.com/questions/3346450/c-what-is-the-difference-between-i-and-i/3346729#3346729">awesome answers on what ++i does</a>. He says this is what really happens:

<ol>
<li>x is evaluated to produce the variable</li>
<li>the value of the variable is copied to a temporary location</li>
<li>the temporary value is incremented to produce a new value (not overwriting the temporary!)</li>
<li>the new value is stored in the variable</li>
<li>the result of the operation is the new value</li>
</ol>

This got me to thinking, what if two threads where calling ++i? If the first thread is at step 3 when the second thread is on step 2. (Meaning what if the second thread copies the value off to the temp location before the first thread stores the new value in the variable?)

If that happens then it would seem that both threads would only increment <code>i</code> once instead of twice. (Unless the whole thing is in a <code>lock</code>.)

Is the ++ operator thread safe?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

注意:我真的不太擅长多线程编程，但我目前的项目让我这样做，所以我试图弄清楚什么是线程安全，什么不是。我在读埃里克·利伯特的。他说这是真正发生的事情：计算代码x以生成变量该变量的值被复制到临时位置临时值递增以生成新值(不覆盖temporary!)the新值存储在变量中操作的结果是新值<>G212</>这让我开始思考，如果...

问++操作符线程安全吗？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问++操作符线程安全吗？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问++操作符线程安全吗？
EN