如何无限期地暂停Java中的线程，然后再恢复它？

也许这个问题以前被问过很多次，但我从未找到满意的答案

问题：

我必须使用循环策略模拟一个进程调度器。我使用线程来模拟进程和多道程序设计；JVM管理线程时，一切正常。但问题是，现在我想控制所有线程，这样我就可以在一定的时间内单独运行每个线程，就像真正的OS进程调度器一样。

我想做的是：

我想有一个所有线程的列表，当我迭代这个列表时，我想执行每个线程对应的数量，但是时间一到，我想无限期地暂停这个线程，直到列表中的所有线程都被执行，然后当我再次到达同一个线程时，继续执行它，依此类推。

问题是：

那么，它们是一种不使用不推荐的方法stop（）、suspend（）或resume（）来控制线程的方法吗？

---

简短回答：不。您无法在Java中实现线程调度程序，因为它的运行级别不够低

如果您真的打算实现一个进程调度器，我希望您需要钩住底层操作系统调用，因此我怀疑这在Java中是否是一个好主意（如果可能的话）。至少，您无法使用

java.lang.Thread

来表示正在运行的线程，因此最好使用较低级别的语言（如C）来完成这些操作。

是的，有：

---

java.util.concurrent

中的Object.wait（）、Object.notify（）和其他一些更好的同步原语谁说java不够低级

这是我的3分钟解决方案。我希望它符合你的需要

import java.util.ArrayList;
import java.util.List;

public class ThreadScheduler {

    private List<RoundRobinProcess> threadList
            = new ArrayList<RoundRobinProcess>();

    public ThreadScheduler(){
        for (int i = 0 ; i < 100 ; i++){
            threadList.add(new RoundRobinProcess());
            new Thread(threadList.get(i)).start();
        }
    }


    private class RoundRobinProcess implements Runnable{

        private final Object lock = new Object();
        private volatile boolean suspend = false , stopped = false;

        @Override
        public void run() {
            while(!stopped){
                while (!suspend){
                    // do work
                }
                synchronized (lock){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        return;
                    }
                }
            }
        }

        public void suspend(){
            suspend = true;
        }
        public void stop(){
            suspend = true;stopped = true;
            synchronized (lock){
                lock.notifyAll();
            }
        }

        public void resume(){
            suspend = false;
            synchronized (lock){
                lock.notifyAll();
            }
        }

    }
}

import java.util.ArrayList；
导入java.util.List；
公共类线程调度程序{
私有列表线程列表
=新的ArrayList（）；
公共线程调度程序（）{
对于（int i=0；i<100；i++）{
添加（新的RoundRobinProcess（））；
新线程（threadList.get（i））.start（）；
}
}
私有类RoundRobinProcess实现可运行{
私有最终对象锁=新对象（）；
private-volatile boolean suspend=false，stopped=false；
@凌驾
公开募捐{
当（！停止）{
而（！挂起）{
//工作
}
已同步（锁定）{
试一试{
lock.wait（）；
}捕捉（中断异常e）{
Thread.currentThread（）.interrupt（）；
返回；
}
}
}
}
公众假期暂停{
suspend=true；
}
公共停车场（）{
suspend=true；stopped=true；
已同步（锁定）{
lock.notifyAll（）；
}
}
公众简历（）{
暂停=错误；
已同步（锁定）{
lock.notifyAll（）；
}
}
}
}

---

请注意，“do work”不应被阻塞。

+1以显示问题的外观！如果您想要的只是一个模拟，那么是否有一种更简单的方法可以使用闩锁而不是使用wait/notify“变脏”呢？我的意思是，低级听起来“聪明”，但实际上不是。。。（只要看看罗曼的答案中容易出错且不可读的代码，我就想吐了；）真的很好的评论wizard先生，相信我，我做了关于使用闩锁的家庭作业。如果你不想反对别人，那么你也可以发布你的答案。很多人甚至不理解下面的答案，因为那里绝对不熟悉等待/通知，所以这个答案是为他们准备的。我发布它是为了学习一点java线程的核心概念。它通常取决于操作系统，所以你甚至不能在应用程序中使用C语言来实现它（除非你使用类似于旧的“绿色”线程）。事实上，大多数操作系统都是用C或C++实现的。我解体了，你只是误解了我猜的问题。他并不是真的想创建一个操作系统。只是一个线程池，它提供了挂起和恢复线程的选项。没有连接到任何C或低电平或其他任何东西。是的，这正是我的意思。但我理解你的论点Andrzej，用Java你会觉得自己处于一个泡沫中，JVM为你做一切。有时候拥有它很好，但有时候你想拥有控制权。关于这种方法的更多信息可以在这里获得：不错，但正如你自己所说，“do work”不应该被阻塞，因此这只适用于有限的用例。通过中断/或通知特定的阻塞操作，可以很容易地消除限制。它确实依赖于“做工作”。这是通用的解决方案。还有一些IO阻塞操作根本无法中断。感谢您的快速回答，我会看看我能做些什么。在我的情况下，“do work”不是阻塞，它只是执行一堆东西。所以不用担心。再次感谢！