C# 线程安全且速度快/高性能的计数器

如何在c#中获得具有最佳性能的线程安全计数器?

这很简单:

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

但是有没有更快的选择呢?

116617 次浏览
小开

尝试使用联锁。增量

小开
最佳答案

这样会更简单:

return Interlocked.Increment(ref COUNTER);

MSDN互锁。增加< / >

小开

我建议你在系统中使用。net内置的联锁增量。线程库。

下面的代码将通过引用增加一个长变量，并且是完全线程安全的:

Interlocked.Increment(ref myNum);

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

小开

正如其他人推荐的那样，Interlocked.Increment将比lock()具有更好的性能。只要看一下IL和Assembly，你就会看到Increment变成了一个“总线锁”。语句及其变量直接递增(x86)或“加”;(x64)。

这辆“巴士锁”;语句锁定总线，以防止另一个CPU在调用CPU执行操作时访问总线。现在，看一下c# lock()语句的IL。在这里你会看到为了开始或结束一个节而调用Monitor。

换句话说，. net lock()语句比. net Interlocked.Increment语句做的多得多。

所以，如果你想做的只是增加一个变量，Interlock.Increment会更快。回顾所有Interlocked方法，以查看可用的各种原子操作，并找到适合您需要的操作。当你想做更复杂的事情，比如多个相互关联的递增/递减，或者序列化对比整数更复杂的资源的访问时，可以使用lock()。

小开

如上所述，使用Interlocked.Increment

来自MS的代码示例:

下面的示例确定需要多少个范围从0到1000的随机数才能生成具有中点值的1000个随机数。为了跟踪中点值的数量，将变量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调用。方法消除了对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


提交答案