blocks|key|445117|text|这样会更简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|445118|return+Interlocked.Increment(ref+COUNTER);|code-block|syntax|javascript|445119|MSDN+Interlocked.Increment|offset|length|445120|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/dd78zt0c.aspx^0|0|0|0|Q|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

This would be simpler:

<pre><code>return Interlocked.Increment(ref COUNTER);
</code></pre>

<a href="http://msdn.microsoft.com/en-us/library/dd78zt0c.aspx">MSDN Interlocked.Increment</a>

blocks|key|227072|text|根据其他人的建议，Interlocked.Increment将比lock()具有更好的性能。只需看一下IL和Assembly，您将看到Increment变成了一个“总线锁”语句，它的变量直接递增(x86)或“加”到(x64)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|227073|这个“总线锁定”语句锁定总线，以防止另一个CPU在调用CPU执行其操作时访问总线。现在，看看C#+lock()语句的IL。在这里，您将看到为了开始或结束一节而调用Monitor。|227074|换句话说，.Net+lock()语句比.Net+Interlocked.Increment做的多得多。|227075|所以，如果你想做的就是增加一个变量，Interlock.Increment会更快。查看所有互锁的方法，以查看各种可用的原子操作，并找到适合您需要的操作。当您想要做更复杂的事情，比如多个相互关联的递增/递减，或者序列化对比整数更复杂的资源的访问时，可以使用lock()。|227076|entityMap^0|9|L|W|6|1V|9|0|1D|6|29|7|0|A|6|O|L|0|I|J|3J|6|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$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]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|M|$]]

As recommended by others, the <code>Interlocked.Increment</code> will have better performance than <code>lock()</code>. Just take a look at the IL and Assembly where you will see that <code>Increment</code> turns into a &quot;bus lock&quot; statement and its variable is directly incremented (x86) or &quot;added&quot; to (x64).
This &quot;bus lock&quot; statement locks the bus to prevent another CPU from accessing the bus while the calling CPU does its operation. Now, take a look at the C# <code>lock()</code> statement's IL. Here you will see calls to <code>Monitor</code> in order to begin or end a section.
In other words, .Net <code>lock()</code> statement is doing a lot more than the .Net <code>Interlocked.Increment</code>.
So, if all you want to do is increment a variable, <code>Interlock.Increment</code> will be faster. Review all of the Interlocked methods to see the various atomic operations available and to find those that suit your needs. Use <code>lock()</code> when you want to do more complex things like multiple inter-related increments/decrements, or to serialize access to resources that are more complex than integers.

blocks|key|445152|text|我建议你在System.Threading库中使用.NET内置的互锁增量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|445153|下面的代码将通过引用递增一个long变量，并且是完全线程安全的：|445154|Interlocked.Increment(ref+myNum);|code-block|syntax|javascript|445155|来源：http://msdn.microsoft.com/en-us/library/dd78zt0c.aspx|offset|length|445156|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/dd78zt0c.aspx^0|0|0|0|3|1H|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

I suggest you use .NET's built in interlock increment in the System.Threading library. 

The following code will increment a long variable by reference and is completely thread safe:

<pre><code>Interlocked.Increment(ref myNum);
</code></pre>

Source: <a href="http://msdn.microsoft.com/en-us/library/dd78zt0c.aspx">http://msdn.microsoft.com/en-us/library/dd78zt0c.aspx</a>

blocks|key|226965|text|尝试使用Interlocked.Increment|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|226966|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/dd78zt0c.aspx^0|4|L|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Try with <a href="http://msdn.microsoft.com/en-us/library/dd78zt0c.aspx" rel="noreferrer">Interlocked.Increment</a>

blocks|key|227115|text|如前所述，使用Interlocked.Increment|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|227116|来自MS的代码示例：|227117|下面的示例确定需要多少个范围从0到1,000的随机数才能生成具有中点值的1,000个随机数。为了跟踪中点值的数量，变量midpointCount被设置为等于0，并在每次随机数生成器返回中点值时递增，直到它达到10,000。因为有三个线程生成随机数，所以会调用Increment(Int32)方法来确保多个线程不会同时更新midpointCount。注意，锁还用于保护随机数生成器，CountdownEvent对象用于确保Main方法不会在三个线程之前完成执行。|227118|using+System;
using+System.Threading;

public+class+Example
{
+++const+int+LOWERBOUND+=+0;
+++const+int+UPPERBOUND+=+1001;

+++static+Object+lockObj+=+new+Object();
+++static+Random+rnd+=+new+Random();
+++static+CountdownEvent+cte;

+++static+int+totalCount+=+0;
+++static+int+totalMidpoint+=+0;
+++static+int+midpointCount+=+0;

+++public+static+void+Main()
+++{
++++++cte+=+new+CountdownEvent(1);
++++++//+Start+three+threads.+
++++++for+(int+ctr+=+0;+ctr+<=+2;+ctr%2B%2B)+{
+++++++++cte.AddCount();
+++++++++Thread+th+=+new+Thread(GenerateNumbers);
+++++++++th.Name+=+"Thread"+%2B+ctr.ToString();
+++++++++th.Start();
++++++}
++++++cte.Signal();
++++++cte.Wait();
++++++Console.WriteLine();
++++++Console.WriteLine("Total+midpoint+values:++{0,10:N0}+({1:P3})",
++++++++++++++++++++++++totalMidpoint,+totalMidpoint/((double)totalCount));
++++++Console.WriteLine("Total+number+of+values:+{0,10:N0}",+
++++++++++++++++++++++++totalCount);++++++++++++++++++
+++}

+++private+static+void+GenerateNumbers()
+++{
++++++int+midpoint+=+(UPPERBOUND+-+LOWERBOUND)+/+2;
++++++int+value+=+0;
++++++int+total+=+0;
++++++int+midpt+=+0;

++++++do+{
+++++++++lock+(lockObj)+{
++++++++++++value+=+rnd.Next(LOWERBOUND,+UPPERBOUND);
+++++++++}
+++++++++if+(value+==+midpoint)+{+
++++++++++++Interlocked.Increment(ref+midpointCount);
++++++++++++midpt%2B%2B;
+++++++++}
+++++++++total%2B%2B;++++
++++++}+while+(midpointCount+<+10000);

++++++Interlocked.Add(ref+totalCount,+total);
++++++Interlocked.Add(ref+totalMidpoint,+midpt);

++++++string+s+=+String.Format("Thread+{0}:\n",+Thread.CurrentThread.Name)+%2B
+++++++++++++++++String.Format("+++Random+Numbers:+{0:N0}\n",+total)+%2B+
+++++++++++++++++String.Format("+++Midpoint+values:+{0:N0}+({1:P3})",+midpt,+
+++++++++++++++++++++++++++++++((double)+midpt)/total);
++++++Console.WriteLine(s);
++++++cte.Signal();
+++}
}
//+The+example+displays+output+like+the+following:
//+++++++Thread+Thread2:
//++++++++++Random+Numbers:+2,776,674
//++++++++++Midpoint+values:+2,773+(0.100+%25)
//+++++++Thread+Thread1:
//++++++++++Random+Numbers:+4,876,100
//++++++++++Midpoint+values:+4,873+(0.100+%25)
//+++++++Thread+Thread0:
//++++++++++Random+Numbers:+2,312,310
//++++++++++Midpoint+values:+2,354+(0.102+%25)
//+++++++
//+++++++Total+midpoint+values:++++++10,000+(0.100+%25)
//+++++++Total+number+of+values:++9,965,084|code-block|syntax|javascript|227119|下面的示例与上一个示例类似，不同之处在于它使用Task类而不是线程过程来生成50,000个随机中点整数。在本例中，λ表达式替换了GenerateNumbers线程过程，对Task.WaitAll方法的调用消除了对CountdownEvent对象的需要。|227120|using+System;
using+System.Collections.Generic;
using+System.Threading;
using+System.Threading.Tasks;

public+class+Example
{
+++const+int+LOWERBOUND+=+0;
+++const+int+UPPERBOUND+=+1001;

+++static+Object+lockObj+=+new+Object();
+++static+Random+rnd+=+new+Random();

+++static+int+totalCount+=+0;
+++static+int+totalMidpoint+=+0;
+++static+int+midpointCount+=+0;

+++public+static+void+Main()
+++{
++++++List<Task>+tasks+=+new+List<Task>();
++++++//+Start+three+tasks.+
++++++for+(int+ctr+=+0;+ctr+<=+2;+ctr%2B%2B)+
+++++++++tasks.Add(Task.Run(+()+=>+{+int+midpoint+=+(UPPERBOUND+-+LOWERBOUND)+/+2;
+++++++++++++++++++++++++++++++++++++int+value+=+0;
+++++++++++++++++++++++++++++++++++++int+total+=+0;
+++++++++++++++++++++++++++++++++++++int+midpt+=+0;

+++++++++++++++++++++++++++++++++++++do+{
++++++++++++++++++++++++++++++++++++++++lock+(lockObj)+{
+++++++++++++++++++++++++++++++++++++++++++value+=+rnd.Next(LOWERBOUND,+UPPERBOUND);
++++++++++++++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++++++++++++++if+(value+==+midpoint)+{+
+++++++++++++++++++++++++++++++++++++++++++Interlocked.Increment(ref+midpointCount);
+++++++++++++++++++++++++++++++++++++++++++midpt%2B%2B;
++++++++++++++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++++++++++++++total%2B%2B;++++
+++++++++++++++++++++++++++++++++++++}+while+(midpointCount+<+50000);

+++++++++++++++++++++++++++++++++++++Interlocked.Add(ref+totalCount,+total);
+++++++++++++++++++++++++++++++++++++Interlocked.Add(ref+totalMidpoint,+midpt);

+++++++++++++++++++++++++++++++++++++string+s+=+String.Format("Task+{0}:\n",+Task.CurrentId)+%2B
++++++++++++++++++++++++++++++++++++++++++++++++String.Format("+++Random+Numbers:+{0:N0}\n",+total)+%2B+
++++++++++++++++++++++++++++++++++++++++++++++++String.Format("+++Midpoint+values:+{0:N0}+({1:P3})",+midpt,+
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++((double)+midpt)/total);
+++++++++++++++++++++++++++++++++++++Console.WriteLine(s);+}+));

++++++Task.WaitAll(tasks.ToArray());
++++++Console.WriteLine();
++++++Console.WriteLine("Total+midpoint+values:++{0,10:N0}+({1:P3})",
++++++++++++++++++++++++totalMidpoint,+totalMidpoint/((double)totalCount));
++++++Console.WriteLine("Total+number+of+values:+{0,10:N0}",+
++++++++++++++++++++++++totalCount);++++++++++++++++++
+++}
}
//+The+example+displays+output+like+the+following:
//+++++++Task+3:
//++++++++++Random+Numbers:+10,855,250
//++++++++++Midpoint+values:+10,823+(0.100+%25)
//+++++++Task+1:
//++++++++++Random+Numbers:+15,243,703
//++++++++++Midpoint+values:+15,110+(0.099+%25)
//+++++++Task+2:
//++++++++++Random+Numbers:+24,107,425
//++++++++++Midpoint+values:+24,067+(0.100+%25)
//+++++++
//+++++++Total+midpoint+values:++++++50,000+(0.100+%25)
//+++++++Total+number+of+values:+50,206,378|227121|https://docs.microsoft.com/en-us/dotnet/api/system.threading.interlocked.increment?view=netcore-3.0|227122|entityMap|0|LINK|mutability|MUTABLE|url^0|7|L|0|0|0|0|0|0|0|2R|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|15|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|16|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|17|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|18|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|19|8|@]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|U|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|T]]]]

As already mentioned use <code>Interlocked.Increment</code>

Code example from MS:

The following example determines how many random numbers that range from 0 to 1,000 are required to generate 1,000 random numbers with a midpoint value. To keep track of the number of midpoint values, a variable, midpointCount, is set equal to 0 and incremented each time the random number generator returns a midpoint value until it reaches 10,000. Because three threads generate the random numbers, the Increment(Int32) method is called to ensure that multiple threads don't update midpointCount concurrently. Note that a lock is also used to protect the random number generator, and that a CountdownEvent object is used to ensure that the Main method doesn't finish execution before the three threads.

<pre><code>using System;
using System.Threading;

public class Example
{
 const int LOWERBOUND = 0;
 const int UPPERBOUND = 1001;

 static Object lockObj = new Object();
 static Random rnd = new Random();
 static CountdownEvent cte;

 static int totalCount = 0;
 static int totalMidpoint = 0;
 static int midpointCount = 0;

 public static void Main()
 {
 cte = new CountdownEvent(1);
 // Start three threads. 
 for (int ctr = 0; ctr &lt;= 2; ctr++) {
 cte.AddCount();
 Thread th = new Thread(GenerateNumbers);
 th.Name = "Thread" + ctr.ToString();
 th.Start();
 }
 cte.Signal();
 cte.Wait();
 Console.WriteLine();
 Console.WriteLine("Total midpoint values: {0,10:N0} ({1:P3})",
 totalMidpoint, totalMidpoint/((double)totalCount));
 Console.WriteLine("Total number of values: {0,10:N0}", 
 totalCount); 
 }

 private static void GenerateNumbers()
 {
 int midpoint = (UPPERBOUND - LOWERBOUND) / 2;
 int value = 0;
 int total = 0;
 int midpt = 0;

 do {
 lock (lockObj) {
 value = rnd.Next(LOWERBOUND, UPPERBOUND);
 }
 if (value == midpoint) { 
 Interlocked.Increment(ref midpointCount);
 midpt++;
 }
 total++; 
 } while (midpointCount &lt; 10000);

 Interlocked.Add(ref totalCount, total);
 Interlocked.Add(ref totalMidpoint, midpt);

 string s = String.Format("Thread {0}:\n", Thread.CurrentThread.Name) +
 String.Format(" Random Numbers: {0:N0}\n", total) + 
 String.Format(" Midpoint values: {0:N0} ({1:P3})", midpt, 
 ((double) midpt)/total);
 Console.WriteLine(s);
 cte.Signal();
 }
}
// The example displays output like the following:
// Thread Thread2:
// Random Numbers: 2,776,674
// Midpoint values: 2,773 (0.100 %)
// Thread Thread1:
// Random Numbers: 4,876,100
// Midpoint values: 4,873 (0.100 %)
// Thread Thread0:
// Random Numbers: 2,312,310
// Midpoint values: 2,354 (0.102 %)
// 
// Total midpoint values: 10,000 (0.100 %)
// Total number of values: 9,965,084
</code></pre>

The following example is similar to the previous one, except that it uses the Task class instead of a thread procedure to generate 50,000 random midpoint integers. In this example, a lambda expression replaces the GenerateNumbers thread procedure, and the call to the Task.WaitAll method eliminates the need for the CountdownEvent object.

<pre><code>using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
 const int LOWERBOUND = 0;
 const int UPPERBOUND = 1001;

 static Object lockObj = new Object();
 static Random rnd = new Random();

 static int totalCount = 0;
 static int totalMidpoint = 0;
 static int midpointCount = 0;

 public static void Main()
 {
 List&lt;Task&gt; tasks = new List&lt;Task&gt;();
 // Start three tasks. 
 for (int ctr = 0; ctr &lt;= 2; ctr++) 
 tasks.Add(Task.Run( () =&gt; { int midpoint = (UPPERBOUND - LOWERBOUND) / 2;
 int value = 0;
 int total = 0;
 int midpt = 0;

 do {
 lock (lockObj) {
 value = rnd.Next(LOWERBOUND, UPPERBOUND);
 }
 if (value == midpoint) { 
 Interlocked.Increment(ref midpointCount);
 midpt++;
 }
 total++; 
 } while (midpointCount &lt; 50000);

 Interlocked.Add(ref totalCount, total);
 Interlocked.Add(ref totalMidpoint, midpt);

 string s = String.Format("Task {0}:\n", Task.CurrentId) +
 String.Format(" Random Numbers: {0:N0}\n", total) + 
 String.Format(" Midpoint values: {0:N0} ({1:P3})", midpt, 
 ((double) midpt)/total);
 Console.WriteLine(s); } ));

 Task.WaitAll(tasks.ToArray());
 Console.WriteLine();
 Console.WriteLine("Total midpoint values: {0,10:N0} ({1:P3})",
 totalMidpoint, totalMidpoint/((double)totalCount));
 Console.WriteLine("Total number of values: {0,10:N0}", 
 totalCount); 
 }
}
// The example displays output like the following:
// Task 3:
// Random Numbers: 10,855,250
// Midpoint values: 10,823 (0.100 %)
// Task 1:
// Random Numbers: 15,243,703
// Midpoint values: 15,110 (0.099 %)
// Task 2:
// Random Numbers: 24,107,425
// Midpoint values: 24,067 (0.100 %)
// 
// Total midpoint values: 50,000 (0.100 %)
// Total number of values: 50,206,378
</code></pre>

<a href="https://docs.microsoft.com/en-us/dotnet/api/system.threading.interlocked.increment?view=netcore-3.0" rel="nofollow noreferrer">https://docs.microsoft.com/en-us/dotnet/api/system.threading.interlocked.increment?view=netcore-3.0</a>

What is the way to obtain a thread safe counter in C# with best possible performance?

This is as simple as it gets:

<pre><code>public static long GetNextValue()
{
 long result;
 lock (LOCK)
 {
 result = COUNTER++;
 }
 return result;
}
</code></pre>

But are there faster alternatives?

C# Thread safe fast(est) counter

在C#中获得具有最佳性能的线程安全计数器的方法是什么？这就是最简单的方法：public static long GetNextValue(){    long result;    lock (LOCK)    {        result = COUNTER++;    }    return result;}但是有没有更快的替代方案呢？

问C#线程安全快速(Est)计数器
EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#线程安全快速(Est)计数器EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#线程安全快速(Est)计数器
EN