C# 多线程编程 经典模型 读者和写者问题
语言：C#
总起：
昨天的生产者消费者模型我们初步学习了多线程的一些知识，今天我们来讨论读者和写者的问题。
如果没有接触过多线程的同学，最好先看下第一篇文章。
Semaphore和Mutex的区别：
昨天说信号量Semaphore的数量为1时跟互斥体Mutex是一样的，但实际上还是有个重要的区别的。
Semaphore在使用时不管在哪个线程获取，其他线程都可以释放。
而Mutex和lock只能是获取到的线程进行释放，如果线程1获取了，线程2就不能进行释放。
读者写者问题：
在消费者和生产者的问题上，我说加同步使只有一个线程操作数据库，保证操作的原子性，这个问题和操作Buffer类似。
不过今天研究了读者写者问题，发现其实是类似读者写者问题。
先让我来描述一下这个问题：在读者写者问题上，其实不管有多少位读者读书（Web上类似查询数据库），其实不做同步也不会产生BUG，做了同步之后反而会减慢性能，但写者和写者之间、写者和读者之间必须做同步。
也就是保证在同一时间内，只有一位写者或者是多位读者的情况。
以下是使用同步后的一个基本的实现：
static Random random = new Random();
// 当前读者的数量
private static int readcount = 0;
// 同步标记
static Mutex rMutex = new Mutex();
static Semaphore resource = new Semaphore(1, 1); // 读写权限
// 读书，随机读1到5秒
public static void Read(string name)
{
Console.WriteLine(name + ": 开始读书 正在读书人数" + readcount);
Thread.Sleep(TimeSpan.FromSeconds(random.Next(1, 5)));
Console.WriteLine(name + ": 完成读书");
}
// 写书，固定3秒
public static void Write(string name)
{
Console.WriteLine(name + ": 开始写书");
Thread.Sleep(TimeSpan.FromSeconds(3));
Console.WriteLine(name + ": 完成写书");
}
// 休息
public static void TakeARest()
{
Thread.Sleep(TimeSpan.FromSeconds(random.Next(1, 10)));
}
private static Thread writerThread;
private static Thread reader1Thread;
private static Thread reader2Thread;
private static Thread reader3Thread;
static void Main(string[] args)
{
// 创建一个写者三个读者
writerThread = new Thread(writer);
reader1Thread = new Thread(reader);
reader2Thread = new Thread(reader);
reader3Thread = new Thread(reader);
writerThread.Start("写者");
reader1Thread.Start("读者1");
reader2Thread.Start("读者2");
reader3Thread.Start("读者3");
}
static void writer(object name)
{
while (true)
{
// 等待读写权限
resource.WaitOne();
// 写书
Write(name.ToString());
// 释放读写权限
resource.Release();
// 休息一下
TakeARest();
}
}
static void reader(object name)
{
while (true)
{
rMutex.WaitOne();
// 需要阅读的人增加计数
readcount++;
// 如果当前是第一位读者，并且没有写者，则获取读写权限
// 如果有写者则等待
// 如果是第一位后面的读者，则直接进入读书操作
if (readcount == 1)
resource.WaitOne();
rMutex.ReleaseMutex();
// 开始阅读
Read(name.ToString());
rMutex.WaitOne();
// 需要阅读的人减少计数
readcount--;
// 如果是最后一位读者，则释放读写权限
// 如果不是最后一位读者，直接离开读书操作
if(readcount == 0)
resource.Release();
rMutex.ReleaseMutex();
// 休息一下
TakeARest();
}
}OK，这边代码需要说明的是对readcount的操作和if语句做了同步，因为该操作不具有原子性的话，可能造成两个读者一起去申请读写权限。
然后我们来看一下结果：
该解决方案可以优化读写问题，是一种读者优先的锁。但是有个缺点，就是如果读者在连续不断进入的情况下，读者们一直占有线程，使进来的写者根本获取不到读写权限，写者线程就会陷入饥饿状态。
这边我没有说错误，是缺点，意思是需要根据具体情况做分析是否采用该方案，还是新的方案，如果说没有写者只有读者，那都不用做同步了，所以具体情况要具体分析。
写者优先的方案：
如果我将读者休息的代码注释掉，那结果如下：
写者线程就陷入饥饿状态了。
以下是改良后的解决方案：
static Random random = new Random();
// 当前读者写者的数量
private static int readcount = 0;
private static int writecount = 0;
// 同步标记
static Mutex rMutex = new Mutex();
static Mutex wMutex = new Mutex();
static Mutex readTry = new Mutex();
static Semaphore resource = new Semaphore(1, 1); // 读写权限
// 读书，随机读1到5秒
public static void Read(string name)
{
Console.WriteLine(name + ": 开始读书 正在读书人数" + readcount);
Thread.Sleep(TimeSpan.FromSeconds(random.Next(1, 5)));
Console.WriteLine(name + ": 完成读书");
}
// 写书，固定3秒
public static void Write(string name)
{
Console.WriteLine(name + ": 开始写书");
Thread.Sleep(TimeSpan.FromSeconds(3));
Console.WriteLine(name + ": 完成写书");
}
// 休息
public static void TakeARest()
{
Thread.Sleep(TimeSpan.FromSeconds(random.Next(1, 10)));
}
private static Thread writerThread;
private static Thread reader1Thread;
private static Thread reader2Thread;
private static Thread reader3Thread;
static void Main(string[] args)
{
// 创建一个写者三个读者
writerThread = new Thread(writer);
reader1Thread = new Thread(reader);
reader2Thread = new Thread(reader);
reader3Thread = new Thread(reader);
writerThread.Start("写者");
reader1Thread.Start("读者1");
reader2Thread.Start("读者2");
reader3Thread.Start("读者3");
}
static void writer(object name)
{
while (true)
{
wMutex.WaitOne();
writecount++;
// 当读者全在阅读时，写者获取readTry权限，是新的读者不能再进入读取
if (writecount == 1)
readTry.WaitOne();
wMutex.WaitOne();
// 等待读写权限
resource.WaitOne();
// 写书
Write(name.ToString());
// 释放读写权限
resource.Release();
wMutex.WaitOne();
writecount--;
if(writecount==0)
readTry.ReleaseMutex();
wMutex.ReleaseMutex();
// 休息一下
TakeARest();
}
}
static void reader(object name)
{
while (true)
{
readTry.WaitOne();
rMutex.WaitOne();
// 需要阅读的人增加计数
readcount++;
// 如果当前是第一位读者，并且没有写者，则获取读写权限
// 如果有写者则等待
// 如果是第一位后面的读者，则直接进入读书操作
if (readcount == 1)
resource.WaitOne();
rMutex.ReleaseMutex();
readTry.ReleaseMutex();
// 开始阅读
Read(name.ToString());
rMutex.WaitOne();
// 需要阅读的人减少计数
readcount--;
// 如果是最后一位读者，则释放读写权限
// 如果不是最后一位读者，直接离开读书操作
if (readcount == 0)
resource.Release();
rMutex.ReleaseMutex();
// 休息一下
//TakeARest();
}
}再运行一下：
可以看到写者没有再陷入饥饿状态。
主要是添加了一个readTry的互斥体，在有新的写者进来的时候，会阻止新的读者进入操作。
但是如果写者源源不断的涌入，则又会造成读者进入饥饿状态。
不会产生饥饿线程的方案：
这边提出第三种方案：
static Random random = new Random();
private static readonly int MAX_READ_COUNT = 3;
// 当前读者写者的数量
private static int readcount = 0;
private static int writecount = 0;
// 同步标记
static Mutex serviceQueue = new Mutex();
static Mutex rMutex = new Mutex();
static Semaphore resource = new Semaphore(1, 1); // 读写权限
// 读书，随机读1到5秒
public static void Read(string name)
{
Console.WriteLine(name + ": 开始读书 正在读书人数" + readcount);
Thread.Sleep(TimeSpan.FromSeconds(random.Next(1, 5)));
Console.WriteLine(name + ": 完成读书");
}
// 写书，固定3秒
public static void Write(string name)
{
Console.WriteLine(name + ": 开始写书");
Thread.Sleep(TimeSpan.FromSeconds(3));
Console.WriteLine(name + ": 完成写书");
}
// 休息
public static void TakeARest()
{
Thread.Sleep(TimeSpan.FromSeconds(random.Next(1, 10)));
}
private static Thread writerThread;
private static Thread reader1Thread;
private static Thread reader2Thread;
private static Thread reader3Thread;
static void Main(string[] args)
{
// 创建一个写者三个读者
writerThread = new Thread(writer);
reader1Thread = new Thread(reader);
reader2Thread = new Thread(reader);
reader3Thread = new Thread(reader);
writerThread.Start("写者");
reader1Thread.Start("读者1");
reader2Thread.Start("读者2");
reader3Thread.Start("读者3");
}
static void writer(object name)
{
while (true)
{
serviceQueue.WaitOne();
// 等待读写权限
resource.WaitOne();
serviceQueue.ReleaseMutex();
// 写书
Write(name.ToString());
// 释放读写权限
resource.Release();
// 休息一下
TakeARest();
}
}
static void reader(object name)
{
while (true)
{
serviceQueue.WaitOne();
rMutex.WaitOne();
// 需要阅读的人增加计数
if (readcount == 0)
resource.WaitOne();
readcount++;
serviceQueue.ReleaseMutex();
rMutex.ReleaseMutex();
// 读书
Read(name.ToString());
rMutex.WaitOne();
// 需要阅读的人减少计数
readcount--;
if (readcount == 0)
resource.Release();
rMutex.ReleaseMutex();
// 休息一下
//TakeARest();
}
}这边添加了一个serviceQueue的互斥体，保证新进来的一个线程不会受到后面进来的线程影响从而陷入饥饿状态。
ReaderWriterLockSlim类：
在C#中已经提供了一个读写锁可直接运用在生产环境中，这边使用该类重写读写程序：
static ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();
static void writer(object name)
{
while (true)
{
rwLock.EnterWriteLock();
Write(name.ToString());
rwLock.ExitWriteLock();
TakeARest();
}
}
static void reader(object name)
{
while (true)
{
rwLock.EnterReadLock();
Read(name.ToString());
rwLock.ExitReadLock();
//TakeARest();
}
}这样就很轻松的解决了问题，并且没有线程饥饿的后顾之忧。
该类还提供了升级降级的功能，不管怎么样C#中都提倡使用。