C#多线程计数器：线程安全读写与增量操作技术问询

修正后的代码 #

public sealed class StatisticsCounter
{
    private static StatisticsCounter instance = null;
    private static readonly object Instancelock = new object();
    private volatile int Counter1 = 0;
    private volatile int Counter2 = 0;

    private StatisticsCounter()
    {
    }

    public static StatisticsCounter GetInstance
    {
        get
        {
            if (instance != null)
            {
                lock (Instancelock)
                {
                    if (instance == null)
                    {
                        instance = new StatisticsCounter();
                    }
                }
            }
            return instance;
        }
    }

    public void IncrementCounter1()
    {   
        Interlocked.Increment(this.Counter1);
    }
    
    public void IncrementCounter2()
    {
        Interlocked.Increment(this.Counter2);
    }

    public string GetStats()
    {
        string stats = null;
        lock (Instancelock)
        {
            stats = string.Format("Counter1 : {0} , Counter2 : {1}", Counter1, Counter2);
            reset();
            return stats;
        }
    }

    private void reset()
    {
        Counter1 = 0;
        Counter2 = 0;
    }
}

问题1：读取计数器值时如何安全施加锁？ #

要保证读取安全，核心是让**读取+关联修改（比如重置）**的操作成为原子性操作，同时和所有计数器写入操作互斥：

• 建议新增一个专用锁对象（不要复用单例初始化的Instancelock，避免扩大锁竞争范围），将读取和重置的完整逻辑包裹在lock代码块中。
• 示例：新增private readonly object _counterLock = new object();，在GetStats和所有修改计数器的方法中统一使用这个锁，确保读写操作互斥。

问题2：增量方法是否需要使用Interlocked？其性能影响如何？ #

• 必须使用Interlocked.Increment：多线程环境下，直接执行Counter1 += 1不是原子操作，会出现多个线程同时读取、修改、写回的竞态条件，导致计数丢失。Interlocked.Increment依赖CPU原子指令实现，能保证每次增量操作的原子性，彻底避免线程安全问题。
• 性能影响：Interlocked是用户态同步操作，没有lock带来的内核态切换开销，性能远优于普通锁。只有在极端高频调用场景下才会有可感知的开销，但和线程不安全导致的数据错误相比，这个成本完全可以接受。

问题3：GetStats方法中加锁是否足以保证计数器读取安全？ #

在当前代码逻辑下，加锁是足够的：

• 锁包裹了读取两个计数器+重置的完整流程，保证了这组操作的原子性，不会出现读取Counter1后Counter2被修改、或者重置操作被打断的情况。
• 配合volatile关键字，能保证读取到的计数器值是内存中的最新值，而非线程缓存的旧值。
• 注意：如果后续修改代码时，有其他地方不通过锁修改计数器，会破坏这个安全性，所以要确保所有计数器的读写操作都遵循同一同步规则。

问题4：读取计数器时其他线程能否调用增量方法？若可以该如何缓解？ #

• 可以调用：当前代码中，增量用的Interlocked和读取用的lock不是同一同步机制，两者不互斥，所以在GetStats执行期间，其他线程仍能调用IncrementCounter1/2，可能导致统计值包含读取过程中新增的计数，或者重置后刚新增的计数被下一次统计清掉。
• 缓解方案：
  1. 统一锁机制：把增量操作也放到同一个锁里，替换Interlocked：

     private readonly object _counterLock = new object();
     public void IncrementCounter1()
     {
         lock(_counterLock) { Counter1++; }
     }
     public string GetStats()
     {
         lock(_counterLock)
         {
             var stats = string.Format("Counter1 : {0} , Counter2 : {1}", Counter1, Counter2);
             reset();
             return stats;
         }
     }
     

     这样读取和增量操作互斥，统计的是精确快照，但会牺牲一点并发性能。
  2. 原子交换重置：用Interlocked.Exchange原子性地把计数器值交换为0，同时获取当前值，不需要锁：

     public string GetStats()
     {
         int c1 = Interlocked.Exchange(ref Counter1, 0);
         int c2 = Interlocked.Exchange(ref Counter2, 0);
         return string.Format("Counter1 : {0} , Counter2 : {1}", c1, c2);
     }
     

     这种方式允许增量操作和读取同时进行，统计的是交换瞬间的累计值，之后的增量会存在新的计数器中，既保证线程安全，又保留了高并发性能。

内容的提问来源于stack exchange，提问作者sadiq jaffar