C#学习笔记 线程同步问题

这是用C#提供的各种类实现的几个线程同步问题。

生产者消费者问题

生产者消费者问题大体是这样的：有几个生产者和几个消费者，共享一个缓冲区。生产者会向缓冲区中添加数据；消费者会从缓冲区中将数据取走。需要处理这两者之间的同步问题。

这里先定义一个自己的线程安全队列。该队列使用两个信号量来处理同步问题。另外在进行操作的时候需要锁定临界区，这里使用lock语句实现。

public class FixedQueue<T>
{
    private T[] array;
    private int _count;
    private SemaphoreSlim empty;
    private SemaphoreSlim full;
    public FixedQueue(int length)
    {
        array = new T[length];
        empty = new SemaphoreSlim(length, length);
        full = new SemaphoreSlim(0, length);
    }
    public int Count
    {
        get { return _count; }
    }
    public void Enqueue(T element)
    {
        empty.Wait();
        lock (array)
        {
            array[_count] = element;
            _count++;
            Console.WriteLine("生产者生产了：" + element);
        }
        full.Release();
    }
    public T Dequeue()
    {
        full.Wait();
        var first = array[0];
        lock (array)
        {
            for (int i = 0; i < _count - 1; ++i)
            {
                array[i] = array[i + 1];
            }
            _count--;
            Console.WriteLine("   消费者消费了：" + first);
        }
        empty.Release();
        return first;
    }
}

有了线程安全的队列之后，就可以解决生产者消费者问题了。

public static void Problem1()
{
    Console.WriteLine("生产者消费者问题1：");
    var queue = new FixedQueue<int>(5);
    var producer1 = new Producer1<int>(queue);
    var consumer1 = new Consumer1<int>(queue);
    var produce = Task.Run(() =>
    {
        for (int i = 0; i < 8; ++i)
        {
            producer1.Produce(i);
        }
    });
    var consume = Task.Run(() =>
    {
        for (int i = 0; i < 8; ++i)
        {
            consumer1.Comsume();
        }
    });
    Task.WhenAll(produce, consume).Wait();
    Console.WriteLine("--------------------------------");
}
public class Producer1<T> : IProducer<T>
{
    private FixedQueue<T> _queue;
    public Producer1(FixedQueue<T> queue)
    {
        _queue = queue;
    }
    public void Produce(T element)
    {
        _queue.Enqueue(element);
    }
}
public class Consumer1<T> : IConsumer<T>
{
    private FixedQueue<T> _queue;
    public Consumer1(FixedQueue<T> queue)
    {
        _queue = queue;
    }
    public T Comsume()
    {
        return _queue.Dequeue();
    }
}

哲学家问题

哲学家问题是这样的：有若干个哲学家围坐在一个圆桌前，有同样数量的筷子均匀放在每个哲学家之间。哲学家吃饭的时候需要使用其左右两边的两个筷子才能吃饭。这里用的策略是让哲学家同时拿起左右两个筷子，如果任何一边没有筷子，哲学家就会一直等待。当每个哲学家吃饱后结束。

首先定义哲学家类，在Eat方法里使用了双检锁技术。

public class Philosopher
{
    private static int _count;
    private int _order;
    private bool isFull;
    private bool[] _chopsticks;
    public Philosopher(int order, bool[] chopsticks)
    {
        _order = order;
        _chopsticks = chopsticks;
    }
    public int Count
    {
        get { return _count; }
        set { _count = value; }
    }
    public bool Eat()
    {
        if (IsAvailable())
        {
            lock (_chopsticks)
            {
                if (IsAvailable())
                {
                    isFull = true;
                    Console.WriteLine($"哲学家{_order}用{_order}和{(_order + 1) % Count}号筷子吃完了");
                    Thread.Sleep(1000);
                }
            }
        }
        return isFull;
    }
    private bool IsAvailable()
    {
        return _chopsticks[_order] && _chopsticks[(_order + 1) % _count];
    }
}

定义好了哲学家类之后，就可以来解决哲学家问题了。

public static void Problem3()
{
    Console.WriteLine("哲学家进餐问题：");
    int N = 5;
    var philosophers = new Philosopher[N];
    var chopsticks = new bool[N];
    var tasks = new Task[N];
    for (int i = 0; i < N; ++i)
    {
        chopsticks[i] = true;
        philosophers[i] = new Philosopher(i, chopsticks);
        philosophers[i].Count = N;
        int order = i;
        tasks[i] = new Task(() =>
        {
            while (!philosophers[order].Eat())
            {
            }
        });
    }
    Parallel.ForEach(tasks, task => task.Start());
    Task.WhenAll(tasks).Wait();
    Console.WriteLine("所有哲学家都用餐完毕");
    Console.WriteLine("--------------------------------");
}

读者写者问题

读者写者问题描述如下：有若干个读者和写者共同操作一份数据。同一时间只允许一个写者对其进行写入。多个读者可以同时读取数据。读者和写者不能同时读写数据。

C#中包含了一个读写锁ReaderWriterLockSlim，专门用来解决读者写者问题的。因此这里就直接使用这个类来实现。

首先定义读者写者使用的数据类和接口：

/// <summary>
/// 读写者问题使用的数据类接口
/// </summary>
public interface IData
{
    int Data { set; get; }
}
public class MyData : IData
{
    private int _data;
    public int Data
    {
        get { return _data; }
        set { _data = value; }
    }
    public override string ToString()
    {
        return _data.ToString();
    }
}

然后使用ReaderWriterLockSlim类来实现读者和写者的同步：

/// <summary>
/// 读者类
/// </summary>
/// <typeparam name="T"></typeparam>
public class Reader<T> where T : IData
{
    private ReaderWriterLockSlim _rwlock;
    private T _data;
    public Reader(ReaderWriterLockSlim rwlock, T data)
    {
        _rwlock = rwlock;
        _data = data;
    }
    public void Read()
    {
        _rwlock.EnterReadLock();
        Console.WriteLine($"读者读到的数据是：{_data.ToString()}");
        _rwlock.ExitReadLock();
    }
}
/// <summary>
/// 写者类
/// </summary>
/// <typeparam name="T"></typeparam>
public class Writer<T> where T : IData
{
    private ReaderWriterLockSlim _rwlock;
    private Random rand = new Random();
    private T _data;
    public Writer(ReaderWriterLockSlim rwlock, T data)
    {
        _rwlock = rwlock;
        _data = data;
    }
    public void Write()
    {
        _rwlock.EnterWriteLock();
        _data.Data = rand.Next(0, 100);
        Console.WriteLine($"写者将数据写为{_data.ToString()}");
        _rwlock.ExitWriteLock();
    }
}

读者和写者实现之后，就可以着手解决问题了：

public static void Problem4()
{
    var rwlock = new ReaderWriterLockSlim();
    var data = new MyData();
    var writer = new Writer<IData>(rwlock, data);
    var rand = new Random();
    var readers = new List<Reader<IData>>()
    {
        new Reader<IData>(rwlock, data),
        new Reader<IData>(rwlock, data),
        new Reader<IData>(rwlock, data)
    };
    var task1 = Task.Run(() =>
    {
        for (int i = 0; i < 2; ++i)
        {
            writer.Write();
            Thread.Sleep(1000);
        }
    });
    Parallel.ForEach(readers, reader =>
    {
        for (int i = 0; i < 2; ++i)
        {
            reader.Read();
            Thread.Sleep(rand.Next(500, 2000));
        }
    });
    Console.ReadKey();
    Console.WriteLine("--------------------------------");
}

CountdownEvent的例子

学生老师问题

这个问题的情景如下：有多个学生同时做作业，所有作业都完成之后通知老师开始批改作业。这里使用CountdownEvent实现。首先定义学生类和老师类，学生类调用Signal方法将其将计数减1，老师类在CountdownEvent上等待所有学生做完作业。

/// <summary>
/// 利用CountdownEvent类进行同步的学生类
/// </summary>
public class Student
{
    private CountdownEvent _count;
    private int _no;
    public Student(CountdownEvent count, int no)
    {
        _count = count;
        _no = no;
    }
    public void FinishWork()
    {
        //如果输出语句放到下面，可能会出现在输出学生完成作业之前
        //老师开始批改作业的情况
        Console.WriteLine($"学生{_no}做完了作业");
        _count.Signal();
    }
}
/// <summary>
/// 利用CountDownEvent类进行同步的老师类
/// </summary>
public class Teacher
{
    private CountdownEvent _count;
    public Teacher(CountdownEvent count)
    {
        _count = count;
    }
    public void CheckWork()
    {
        _count.Wait();
        Console.WriteLine("老师开始批改作业");
    }
}

两个类定义好了之后，就可以模拟这个问题了：

public static void Problem5()
{
    Console.WriteLine("所有学生做完作业之后，老师才能开始批改作业:");
    int studentsNo = 5;
    var count = new CountdownEvent(studentsNo);
    var students = new Student[studentsNo];
    var dowork = new Task[studentsNo];
    var teacher = new Teacher(count);
    for (int i = 0; i < studentsNo; ++i)
    {
        students[i] = new Student(count, i + 1);
        int no = i;
        dowork[i] = Task.Run(() => students[no].FinishWork());
    }
    teacher.CheckWork();
    Task.WhenAll(dowork).Wait();
    Console.WriteLine("--------------------------------");
}

赛马的模拟程序

这个例子是我看《Java编程思想》里面的一个例子，在这里用C#改写了一下。首先先看看Horse类，这个类中的Track方法返回一个模拟赛马行进的字符串。Run方法模拟赛马的行进，每匹马每次随机前进0-2步。

class Horse
{
    private static int _count;
    private int id;
    private int _strides;
    private object _syncLock = new object();
    private CountdownEvent _down;
    private static Random _rand = new Random();
    public Horse(CountdownEvent down)
    {
        id = _count++;
        _down = down;
    }
    public override string ToString()
    {
        return $"Horse {id}";
    }
    public string Tracks()
    {
        var sb = new StringBuilder();
        for (int i = 0; i < Strides; ++i)
        {
            sb.Append("*");
        }
        sb.Append(id);
        return sb.ToString();
    }
    public int Strides
    {
        get
        {
            lock (_syncLock)
            {
                return _strides;
            }
        }
    }
    public void Run()
    {
        _strides += _rand.Next(0, 3);
        _down.Signal();
    }
}

然后是HorseRace类，其中Print方法打印几匹马每一次的行进轨迹。NextRun方法让每匹马再继续跑下一步，在Start方法中一直调用这两个方法，模拟赛马的状态。当有一匹马超出重点线，程序结束。

public static void Problem6()
{
    var race = new HorseRace(7);
    race.Start();
}
class HorseRace
{
    public const int FinishLine = 25;
    private List<Horse> _horses = new List<Horse>();
    private CountdownEvent _down;
    public HorseRace(int nHorse)
    {
        _down = new CountdownEvent(nHorse);
        for (int i = 0; i < nHorse; ++i)
        {
            _horses.Add(new Horse(_down));
        }
    }
    private void Print()
    {
        _down.Wait();
        var sb = new StringBuilder();
        for (int i = 0; i < FinishLine; ++i)
        {
            sb.Append("=");
        }
        Console.WriteLine(sb);
        foreach (var horse in _horses)
        {
            Console.WriteLine(horse.Tracks());
            if (horse.Strides >= FinishLine)
            {
                Console.WriteLine($"{horse} 赢了");
                return;
            }
        }
        _down.Reset();
    }
    private void NextRun()
    {
        Parallel.ForEach(_horses, horse => horse.Run());
    }
    public void Start()
    {
        while (_horses.Select(horse => horse.Strides).Max() < FinishLine)
        {
            NextRun();
            Print();
            Thread.Sleep(500);
        }
    }
}