2

我正在尝试模拟（非常基本和简单的）操作系统进程管理器子系统，我有三个“进程”（工作人员）向控制台写入内容（这是一个示例）：

    public class Message
    {
        public Message() { }
        public void Show()
        {
            while (true)
            {
                Console.WriteLine("Something");
                Thread.Sleep(100);
            }
        }
    }

每个工人都应该在不同的线程上运行。我现在就是这样做的：我有一个 Process 类，它的构造函数接受 Action 委托并从中启动一个线程并挂起它。

public class Process
{
    Thread thrd;
    Action act;

    public Process(Action act)
    {
        this.act = act;

        thrd = new Thread(new ThreadStart(this.act));
        thrd.Start();
        thrd.Suspend();
    }

    public void Suspend()
    {
        thrd.Suspend();
    }

    public void Resume()
    {
        thrd.Resume();
    }
}

在那种状态下，它会在我的调度程序恢复它之前等待，给它一个运行时间片，然后再次挂起它。

        public void Scheduler()
        {
            while (true)
            {
                //ProcessQueue is just FIFO queue for processes
                //MainQueue is FIFO queue for ProcessQueue's
                ProcessQueue currentQueue = mainQueue.Dequeue();
                int count = currentQueue.Count;

                if (currentQueue.Count > 0)
                {
                    while (count > 0)
                    {
                        Process currentProcess = currentQueue.GetNext();

                        currentProcess.Resume();
                        //this is the time slice given to the process
                        Thread.Sleep(1000);
                        currentProcess.Suspend();

                        Console.WriteLine();
                        currentQueue.Add(currentProcess);

                        count--;
                    }
                }

                mainQueue.Enqueue(currentQueue);
            }
        }

问题是它不能始终如一地工作。它甚至在这种状态下根本不起作用，我必须在工人的 Show() 方法中的 WriteLine 之前添加 Thread.Sleep() ，就像这样。

        public void Show()
        {
            while (true)
            {
                Thread.Sleep(100); //Without this line code doesn't work
                Console.WriteLine("Something");
                Thread.Sleep(100);
            }
        }

我一直在尝试使用 ManualResetEvent 而不是挂起/恢复，它可以工作，但是由于该事件是共享的，因此依赖它的所有线程同时唤醒，而我一次只需要一个特定线程处于活动状态。

如果有人可以帮助我弄清楚如何正常暂停/恢复任务/线程，那就太好了。我正在做的是试图模拟简单的抢先式多任务处理。谢谢。

4

3 回答 3

4

Thread.Suspend是邪恶的。它和 一样邪恶Thread.Abort。在任意、不可预测的位置暂停时，几乎没有代码是安全的。它可能持有一个锁，导致其他线程也暂停。您很快就会在系统的其他部分遇到死锁或不可预知的停顿。

想象一下，您不小心暂停了string. 现在所有想要使用 a 的代码也都string停止了。Regex内部使用锁定的缓存。如果您在获取此锁时暂停，所有Regex相关代码都可能会暂停。这只是两个令人震惊的例子。

可能，在类深处暂停一些代码Console会产生意想不到的后果。

我不知道该向你推荐什么。这似乎是一个学术练习，所以谢天谢地，这对你来说不是生产问题。用户模式的等待和取消在实践中必须是协同的。

于 2014-05-01T14:07:00.527 回答
0

关于Suspend()and ，我能给出的最好的建议是Resume()：不要使用它。你做错了™。

每当你想使用Suspend()和Resume()配对来控制你的线程时，你应该立即退后一步，问问自己，你在这里做什么。我理解，程序员倾向于将代码路径的执行视为必须控制的东西，就像一些需要永久命令和控制的愚蠢的僵尸工人一样。这可能是在学校和大学里学到的关于计算机的知识的一个功能：计算机只做你告诉他们的事情。

女士们先生们，坏消息是：如果你这样做，这就是所谓的“微观管理”，甚至有人称之为“控制狂思维”。

相反，我强烈建议您以不同的方式思考它。试着把你的线程想象成智能实体，它们不会造成伤害，它们唯一想要的就是得到足够的工作。他们只需要一点指导，仅此而已。您可以在他们面前放置一个装满工作的容器（工作任务队列），并让他们在完成之前的任务后自己从该容器中提取任务。当容器为空时，所有任务都被处理并且没有什么可做的，它们被允许进入睡眠状态，并且WaitFor(alarm)每当有新任务到达时都会发出信号。

因此，与其指挥和控制一群愚蠢的僵尸奴隶，如果不敲响他们身后的鞭子，他们就什么都做不了，而是故意引导一群聪明的同事，让它发生。这就是构建可扩展架构的方式。你不必是一个控制狂，只要对你自己的代码有一点信心。

当然，与往常一样，该规则也有例外。但是没有那么多，我建议从工作假设开始，您的代码可能是规则，而不是例外。

于 2014-05-01T17:08:16.500 回答
0

我设法使用带有 ManualResetEvent 数组的静态类来解决这个问题，其中每个进程都由它的唯一 ID 标识。但我认为这样做很肮脏。我对实现这一目标的其他方式持开放态度。UPD：添加锁以保证线程安全

public sealed class ControlEvent
    {
        private static ManualResetEvent[] control = new ManualResetEvent[100];

        private static readonly object _locker = new object();

        private ControlEvent() { }

        public static object Locker
        {
            get
            {
                return _locker;
            }
        }

        public static void Set(int PID)
        {
            control[PID].Set();
        }

        public static void Reset(int PID)
        {
            control[PID].Reset();
        }

        public static ManualResetEvent Init(int PID)
        {
            control[PID] = new ManualResetEvent(false);
            return control[PID];
        }
    }

在工人阶级

public class RandomNumber
    {
        static Random R = new Random();

        ManualResetEvent evt;

        public ManualResetEvent Event
        {
            get
            {
                return evt;
            }
            set
            {
                evt = value;
            }
        }

        public void Show()
        {
            while (true)
            {
                evt.WaitOne();
                lock (ControlEvent.Locker)
                {
                   Console.WriteLine("Random number: " + R.Next(1000));
                }
                Thread.Sleep(100);
            }
        }
    }

在流程创建事件中

RandomNumber R = new RandomNumber();

Process proc = new Process(new Action(R.Show));

R.Event = ControlEvent.Init(proc.PID);

最后，在调度程序中

public void Scheduler()
        {
            while (true)
            {
                ProcessQueue currentQueue = mainQueue.Dequeue();
                int count = currentQueue.Count;

                if (currentQueue.Count > 0)
                {
                    while (count > 0)
                    {
                        Process currentProcess = currentQueue.GetNext();

                        //this wakes the thread
                        ControlEvent.Set(currentProcess.PID);

                        Thread.Sleep(quant);

                        //this makes it wait again
                        ControlEvent.Reset(currentProcess.PID);

                        currentQueue.Add(currentProcess);

                        count--;
                    }
                }

                mainQueue.Enqueue(currentQueue);
            }
        }
于 2014-05-01T15:10:03.367 回答