【C# & 多线程】多线程中的同步机制。如何安全的读写共享变量。

概念

同步是确保并发任务之间正确交互的一种方式。在多线程环境中，如果没有适当的同步机制，线程之间的交互可能会变得混乱，导致数据不一致、竞态条件等问题。同步的主要目的是控制对共享资源的访问，确保线程之间的正确协作和顺序执行。

竞态条件发生在以下情况：

• 一个线程正在读取或修改一个静态变量。
• 在第一个线程完成操作之前，另一个线程也尝试读取或修改同一个静态变量。
• 由于线程调度的不确定性，第二个线程可能会先完成操作，导致第一个线程看到的数据不是最新的或预期的数据。

实现方式

• 互斥锁：互斥锁是一种用于保护共享资源的机制，它允许一个线程独占资源，直到它释放锁。其他尝试访问该资源的线程将被阻塞，直到锁被释放。
  在C#中提供了 lock() 语言关键字，实现简单的互斥锁。
• 读写锁：读写锁允许多个线程同时读取共享资源，但只允许一个线程写入。这对于读操作远多于写操作的场景非常有用。
  在C#中提供了 ReaderWriterLockSlim 类，实现了读写锁的功能。
• 其他操作同步方式。

演示案例

不使用同步机制：

public class ThreadSafeIntProperty
{
    public int MyProperty { get; set; }

    public void Increment()
    {
        MyProperty++;
    }
}

互斥锁：

在这个例子中，MyProperty 的 set 访问器使用了 lock 语句来确保在修改 myProperty 字段时只有一个线程可以执行。这确保了即使在多线程环境中，MyProperty 的值也会被安全地更新。

public class ThreadSafeIntProperty
{
    private readonly object lockObject = new object();
    private int myProperty;

    public int MyProperty
    {
        // 读取操作通常不需要锁 
        get => myProperty;
        set
        {
            // 使用lock确保设置属性时的线程安全 
            lock (lockObject)
            {
                myProperty = value;
            }
        }
    }
    public void Increment()
    {
        lock(lockObject)
        {
            myProperty++;
        }
    }
}

对于整数类型，还可以使用 Interlocked 类中的Exchange方法，来确保对整数类型的属性的线程安全访问，而无需显式地使用 lock 语句。Interlocked 类提供了一系列原子操作，这些操作可以确保在多线程环境中变量的正确同步。

using System.Threading;  
  
public class ThreadSafeIntProperty
{
    private volatile int myProperty;

    public int MyProperty
    {
        get => myProperty;
        set => Interlocked.Exchange(ref myProperty, value);
    }

    public void Increment()
    {
        Interlocked.Increment(ref myProperty);
    }
}

读写锁

ReaderWriterLockSlim 是一个更灵活且高性能的同步原语，它比简单的 lock 语句提供了更细粒度的控制。它允许多个读取者同时访问共享资源，而只允许一个写入者独占资源。这对于读操作远多于写操作的场景特别有用，因为它可以提高并发性能。

using System.Threading;  
  
public class ThreadSafeIntProperty
{
    private int myProperty;
    private readonly ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();

    public int MyProperty
    {
        get
        {
            rwLock.EnterReadLock(); // 进入读锁  
            try
            {
                // 读取操作  
                return myProperty;
            }
            finally
            {
                rwLock.ExitReadLock(); // 退出读锁  
            }
        }
        set
        {
            rwLock.EnterWriteLock(); // 进入写锁  
            try
            {
                // 写入操作  
                myProperty = value; // 正确的赋值  
            }
            finally
            {
                rwLock.ExitWriteLock(); // 退出写锁  
            }
        }
    }

    public void Increment()
    {
        rwLock.EnterUpgradeableReadLock();
        try
        {
            myProperty++;
        }
        finally
        {
            rwLock.ExitUpgradeableReadLock();
        }

    }
}

测试应用

在这个例子中，我们创建了5个线程，每个线程都会尝试增加sharedCounter.MyProperty的值1000次。

如果使用同步机制，最终的值预期为5000（5个线程每个线程增加1000次）。
如果没有使用同步机制，则最终的值预期小于5000。

通过此例子，可以验证同步机制在多线程中的作用是必要的。

class Program  
{  
    static void Main()  
    {  
        ThreadSafeIntProperty sharedCounter = new ThreadSafeIntProperty();  
		const int numThreads = 5;
		const int iterations = 1000;
		Thread[] threads = new Thread[numThreads];
		// 启动多个线程来增加共享计数器的值  
		for (int i = 0; i < numThreads; i++)
		{
		    threads[i] = new Thread(() =>
		    {
		        for (int j = 0; j < iterations; j++)
		        {
		        	// 尝试增加共享变量的值 
		           	//sharedCounter.MyProperty++;  //使用自加操作不是安全操作。需要修改。
					sharedCounter.Increment();
		            Thread.Sleep(1);
		        }
		    });
		   threads[i].Start();
		}
		foreach (var thread in threads)
		{
		    thread.Join();
		}
    	// 输出最终的计数器值  
        Console.WriteLine($"Final Counter Value: {sharedCounter.MyProperty}");   
   }  
}

问题（自加自减存在的风险 ）

如果MyProperty属性的get和set访问器都加了lock语句，并且您尝试使 sharedCounter.MyProperty++来增加计数器的值，那么最终的结果可能不是正确。
这是因为sharedCounter.MyProperty++实际上是一个隐式的读取和写入操作，而这两个操作都不是原子的。
当您执行sharedCounter.MyProperty++时，实际上发生了以下步骤：

• 读取MyProperty的当前值。
• 将该值加1。
• 将加1后的新值写回MyProperty。

由于MyProperty的get和set访问器都被锁定，这些步骤中的每一个都会获取锁。如果多个线程同时尝试执行MyProperty++操作，它们可能会互相阻塞，导致线程争用和性能下降。

此外，即使get和set操作都是线程安全的，MyProperty++本身仍然不是原子的。这意味着在读取值、加1和写回新值的过程中，可能会有其他线程修改Value的值，导致数据不一致。

所有原创文章皆为本人自学笔记
---- 多学习多讨论多交流 ----多多指教