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

概念实现方式演示案例不使用同步机制:互斥锁:读写锁测试应用

问题(自加自减存在的风险 )

概念

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

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

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

实现方式

互斥锁:互斥锁是一种用于保护共享资源的机制,它允许一个线程独占资源,直到它释放锁。其他尝试访问该资源的线程将被阻塞,直到锁被释放。 在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的值,导致数据不一致。

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

文章来源

评论可见,请评论后查看内容,谢谢!!!评论后请刷新页面。

大家都在找:

c#:cctv5体育频道在线直播

开发语言:软件开发语言排名