C#线程安全的快速（最快）计数器

Question

如何在C#中获得最佳性能的线程安全计数器？

这很简单：

public static long GetNextValue()
{
    long result;
    lock (LOCK)
    {
        result = COUNTER++;
    }
    return result;
}

但是是否有更快的替代方案呢？

- JohnDoDo

Answer 1

这样会更简单：

return Interlocked.Increment(ref COUNTER);

MSDN Interlocked.Increment

- Austin Salonen

---

这很快，但在极端性能场景下仍然不够快。尽管如此，我们也没有更好的选择。 - apen

Answer 2

正如其他人所建议的那样，Interlocked.Increment的性能比lock()更好。只需看一下IL和Assembly，就会发现Increment转换成了“总线锁”语句，并且它的变量直接增加（x86）或者“添加”（x64）。

这个“总线锁”语句锁定了总线，防止另一个CPU在调用CPU执行操作时访问总线。现在，看一下C# lock() 语句的IL，您将看到调用Monitor以开始或结束一个代码块。

换句话说，.Net lock()语句执行的操作比 .Net Interlocked.Increment多得多。

因此，如果您只想对变量进行递增操作，Interlocked.Increment会更快。查看所有Interlocked方法以查看可用的各种原子操作，并找到适合您需要的操作。当您要执行多个相互关联的递增/递减，或串行访问比整数更复杂的资源时，请使用lock()。

- Les

---

-1 是指不需要实现细节。锁定确实比原子操作慢得多，但这与 IL 无关。如果不考虑函数调用的语义，它们将比原子操作快得多，而这不是 IL 固有要求的部分。 - Puppy

Answer 3

我建议您使用 .NET 的内置原子增量在 System.Threading 库中。

以下代码将通过引用递增长整型变量，并完全保证线程安全：

Interlocked.Increment(ref myNum);

来源：http://msdn.microsoft.com/en-us/library/dd78zt0c.aspx

- Andrew White

Answer 4

尝试使用Interlocked.Increment函数。

- fsimonazzi

Answer 5

如前所述，请使用Interlocked.Increment

来自微软的代码示例：

以下示例确定需要多少个介于0到1,000之间的随机数才能生成1,000个具有中点值的随机数。为了跟踪中点值的数量，将一个变量midpointCount设置为0，并在随机数生成器返回中点值时递增，直到达到10,000。由于三个线程生成随机数，因此调用Increment(Int32)方法以确保多个线程不会同时更新midpointCount。请注意，还使用锁来保护随机数生成器，并使用CountdownEvent对象确保Main方法在三个线程之前完成执行。

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++) {
         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 < 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

以下示例与上一个示例类似，只是它使用 Task 类代替线程过程来生成 50,000 个随机中点整数。在本示例中，lambda 表达式替换了 GenerateNumbers 线程过程，并且对 Task.WaitAll 方法的调用消除了 CountdownEvent 对象的需要。

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++) 
         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++;
                                        }
                                        total++;    
                                     } while (midpointCount < 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

https://learn.microsoft.com/en-us/dotnet/api/system.threading.interlocked.increment?view=netcore-3.0

- Ogglas