- \n
- we have a global variable named
counter<\/code>,<\/li>\n\n\n\n- we run many threads at the same time that increment the
counter<\/code> value.<\/li>\n<\/ul>\n\n\n\nAt first everything looks fine as incrementing the
counter<\/code> looks like something that cannot be messed up in terms of accessing by many threads – but it is not true. As you can read in the docs<\/a> – on most computers incrementing is not an atomic operation and consists of three steps:<\/p>\n\n\n\n- \n
- load a
counter<\/code> value into a register,<\/li>\n\n\n\n- increment the value,<\/li>\n\n\n\n
- store a value in the
counter<\/code> variable. <\/li>\n<\/ul>\n\n\n\nAs you can see instead of one (apparently) one atomic operation there are tree steps that happen behind the scene. Thread can be preempted after executing the first two steps, then another thread executes all three steps and at the end first thread finishes the last step. In this case instead of having the
counter + 2<\/code> result the result iscounter + 1<\/code>:<\/p>\n\n\n\n![\"\"](\"https:\/\/baldsolutions.com\/wp-content\/uploads\/2023\/10\/image-6.png\")
<\/figure>\n\n\n\nExample<\/h1>\n\n\n\n
Let’s consider the source code from my GitHub<\/a>. As you can see the
StandardIncrement<\/code> method increments passed argument using++<\/code> operator whereas theInterlockedIncrement<\/code> method uses theInterlocked.Increment<\/code>. If you run the provided code usingdotnet run -c Release<\/code> command you might see a similar output:<\/p>\n\n\n\nStandardIncrement: 9985\nInterlockedIncrement: 10000<\/code><\/pre>\n\n\n\nBehind the scene<\/h1>\n\n\n\n
Let’s see what are the ASM instructions for the source code. For this purpose we will use sharplab<\/a> – interesting part of the output is highlighted:<\/p>\n\n\n\n
![\"\"](\"https:\/\/baldsolutions.com\/wp-content\/uploads\/2023\/10\/image-9.png\")
<\/figure>\n\n\n\nWhat we can see is that these two methods (while doing the same) are represented by slightly different instructions. The
InterlockedIncrement <\/code>method uses the LOCK prefix which makes the instruction atomic whereas theStandardIncrement<\/code> does not (interesting explanation in the link<\/a>).<\/p>\n\n\n\nSummary<\/h1>\n\n\n\n
In this post I presented and explained the
Interlocked<\/code> synchronization primitive in the .NET environment. The API <\/a> of theInterlocked<\/code> class consists of many methods and I encourage you to give it a try on your own. As always you can find source code on my GitHub <\/a>repository.<\/p>\n\n\n\nHave a nice day, bye!<\/p>\n","protected":false},"excerpt":{"rendered":"
Introduction To coordinate threads interaction when accessing a shared resource some kind of synchronization mechanism is required. .NET offers many synchronization primitives that user can…<\/p>\n
- we run many threads at the same time that increment the