在 C# 中获得具有最佳性能的线程安全计数器的方法是什么？
这很简单：
public static long GetNextValue()
{
long result;
lock (LOCK)
{
result = COUNTER++;
}
return result;
}
但是有更快的选择吗？
问问题
104398 次
5 回答
305
于 2012-11-01T16:50:13.737 回答
120
正如其他人推荐的那样，Interlocked.Increment将具有比 更好的性能lock()。只需看一下 IL 和 Assembly，您就会看到它Increment变成了“总线锁”语句，并且它的变量直接递增（x86）或“添加”到（x64）。
此“总线锁定”语句锁定总线以防止另一个 CPU 在调用 CPU 执行其操作时访问总线。现在，看一下 C#lock()语句的 IL。在这里，您将看到调用以Monitor开始或结束一个部分。
换句话说，.Netlock()声明比 .Net 做的更多Interlocked.Increment。
所以，如果你想做的只是增加一个变量，Interlock.Increment会更快。查看所有 Interlocked 方法以查看各种可用的原子操作并找到适合您需要的操作。lock()当您想要执行更复杂的事情（例如多个相互关联的递增/递减）或序列化对比整数更复杂的资源的访问时使用。
于 2012-11-01T17:20:20.657 回答
39
我建议您在 System.Threading 库中使用 .NET 的内置互锁增量。
以下代码将通过引用递增一个 long 变量，并且是完全线程安全的：
Interlocked.Increment(ref myNum);
于 2012-11-01T16:50:43.303 回答
19
于 2012-11-01T16:49:40.680 回答
0
如前所述，使用Interlocked.Increment
来自 MS 的代码示例：
以下示例确定需要多少个 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://docs.microsoft.com/en-us/dotnet/api/system.threading.interlocked.increment?view=netcore-3.0
于 2019-10-08T06:46:34.897 回答