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

野性酷女 2022-07-29 11:19 119阅读 0赞

这是用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);
            }
        }
    }