C# 在实现罗宾回合的同时解决问题

我试图创建一个调度程序（为了好玩），但失败了。奇怪的是，当我以分步调试的方式调试时，我的程序运行得很好，但当我删除所有断点时，它会在打印最后一个值后冻结。所以问题是：为什么它会冻结？第二：我正在使用

线程.Resume

和

线程.Suspend

，但它们被标记为过时。我怎样才能避免呢

代码如下：

using System;
using System.Collections.Generic;
using System.Threading;

namespace ConsoleApplication143
{
    internal class Program
    {
        private static void Main()
        {
            var rrs = new RobinRoundSheduler(2, () =>
                                                {
                                                    for (int i = 0; i < 2; i++)
                                                    {
                                                        Console.WriteLine("{0} {1}", i,
                                                                          Thread.CurrentThread.ManagedThreadId);
                                                    }

                                                }) {TimeForTask = new TimeSpan(1)};
            rrs.Start();
            Console.ReadKey();
        }
    }


    internal class RobinRoundSheduler
    {
        private readonly LinkedList<Thread> _threads;
        public TimeSpan TimeForTask { get; set; }

        public RobinRoundSheduler(int taskCount, ThreadStart start)
        {
            TimeForTask = TimeSpan.FromSeconds(1);
            _threads = new LinkedList<Thread>();
            for (int i = 0; i < taskCount; i++)
            {
                _threads.AddLast(new Thread(start));
            }
        }

        public void Start()
        {
            while (_threads.Count > 0)
            {
                var list = new List<Thread>();
                foreach (var thread in _threads)
                {
                    lock (thread)
                    {
                        if (thread.ThreadState == ThreadState.Unstarted)
                            thread.Start();
                        else
                            thread.Resume();
                    }
                    thread.Join(TimeForTask);
                    lock (thread)
                    {
                        if (thread.ThreadState == ThreadState.Stopped || thread.ThreadState == ThreadState.Aborted)
                            list.Add(thread);
                        else
                        {
                            thread.Suspend();
                        }
                    }
                }
                list.ForEach(thread => _threads.Remove(thread));
            }
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用系统线程；
命名空间控制台应用程序143
{
内部课程计划
{
私有静态void Main（）
{
var rrs=新的RobinRoundScheduler（2，（）=>
{
对于（int i=0；i<2；i++）
{
Console.WriteLine（“{0}{1}”），i，
Thread.CurrentThread.ManagedThreadId）；
}
}){TimeForTask=newtimespan（1）}；
rrs.Start（）；
Console.ReadKey（）；
}
}
内部类robinRoundScheduler
{
私有只读链接列表线程；
公共时间跨度时间任务{get；set；}
公共RobinRoundScheduler（int taskCount，ThreadStart）
{
TimePortTask=TimeSpan.FromSeconds（1）；
_threads=newlinkedlist（）；
对于（int i=0；i0）
{
var list=新列表（）；
foreach（var线程在_线程中）
{
锁（螺纹）
{
if（thread.ThreadState==ThreadState.Unstarted）
thread.Start（）；
其他的
thread.Resume（）；
}
线程连接（TimeForTask）；
锁（螺纹）
{
if（thread.ThreadState==ThreadState.Stopped | | thread.ThreadState==ThreadState.Aborted）
列表。添加（线程）；
其他的
{
thread.Suspend（）；
}
}
}
list.ForEach（thread=>_threads.Remove（thread））；
}
}
}
}

---

由于Thread.Suspend（）方法，它似乎存在死锁问题，但我不知道在调用方法中不添加ManualResetEvents检查的情况下挂起线程的其他方法。但我想调用对多线程一无所知的方法。

还有，为什么要挂起呢？（除了这个API几乎永远不能被使用的事实之外）。您正在加入线程，而不管它们的状态如何。您可能会加入一个挂起的线程。锁似乎没有被使用，但它也不能在所有情况下保护

\u线程

。如果使用

线程.Resume（），我如何等待挂起的线程之前？不知道你的意思。在我帮助你之前，你必须回答我的问题并思考我发现的问题。