Java 主线程和从线程应使用ctrl+；C

我正在编写一个程序，其中主类初始化并启动一个主线程。此主线程启动

n

从线程。程序应使用

Ctrl+C

终止。主线程必须停止从线程，并最终停止自身。 我读了很多关于

addShutdownHook

的书，下面是我的简化实现：

package dictator;

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

public class Main {

    public static void main(String[] args) {
        Master m = new Master();
        m.start();
    }
}

class Master extends Thread {

    List<Slave> slaveMonitor = new ArrayList<Slave>();

    public Master() {
        for (int i = 0; i < 4; i++) {
            Slave slaveThread = new Slave();
            slaveMonitor.add(slaveThread);
        }

        Thread shutDown = new Thread() {
            @Override
            public void run() {
                try {
                    System.out.format("%nShutting down threads...%n");
                    for (Slave s : slaveMonitor) {
                        s.interrupt();
                        s.join();
                    }
                    interrupt()
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
        };
        Runtime.getRuntime().addShutdownHook(shutDown);
    }

    @Override
    public void run() {
        for (Slave s : slaveMonitor) {
            s.start();
        }

        while (true) {
            System.out.println(getName() + " - Master");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                System.out.println(getName() + " interrupted.");
               break;
            }
        }
        System.out.println(getName() + " exiting.");
    }
}

class Slave extends Thread {

    public Slave() {}

    @Override 
    public void run() {
        while (true) {
            System.out.println(getName() + " - Slave");
            try {
                Thread.sleep(1500);
            } catch (InterruptedException ex) {
                System.out.println(getName() + " interrupted.");
                break;
            }
        }
    }
}

我不应该看到下面这行吗？我做错了什么

更换主线程

类主控扩展线程{
List slaveMonitor=new ArrayList（）；
List killList=new ArrayList（）；
公共硕士（）{
对于（int i=0；i<4；i++）{
Slave slaveThread=new Slave（）；
添加（slaveThread）；
}
killList.add（这个）；
线程关闭=新线程（）{
@凌驾
公开募捐{
试一试{
killList.addAll（slaveMonitor）；
收藏。反向（killList）；
System.out.format（“%n正在关闭线程…%n”）；
对于（线程t:killList）{
t、 中断（）；
t、 join（）；
}
}捕获（中断异常例外）{
例如printStackTrace（）；
System.out.println（“中断关机过程”）；
系统出口（1）；
}
}
};
Runtime.getRuntime（）.addShutdownHook（shutDown）；
}
...

您的关闭线程从不中断主线程。它是与主线程分离的线程，因此当您调用

   interrupt() 

在其主体中，您要求该线程中断自身。您需要将主线程添加到要终止的线程列表中

将代码更改为：

  List<Thread> killList = new ArrayList<Thread>();
   ....
    for (int i = 0; i < 4; i++) {
        Slave slaveThread = new Slave();
        slaveMonitor.add(slaveThread);
    }
    killList.addAll(slaveMonitor);
    killList.add(this);

List killList=new ArrayList（）；
....
对于（int i=0；i<4；i++）{
Slave slaveThread=new Slave（）；
添加（slaveThread）；
}
killList.addAll（slaveMonitor）；
killList.add（这个）；

---

并使用

killList

终止线程。

您的关闭线程从不中断主线程。它是与主线程分离的线程，因此当您调用

   interrupt() 

在其主体中，您要求该线程中断自身。您需要将主线程添加到要终止的线程列表中

将代码更改为：

  List<Thread> killList = new ArrayList<Thread>();
   ....
    for (int i = 0; i < 4; i++) {
        Slave slaveThread = new Slave();
        slaveMonitor.add(slaveThread);
    }
    killList.addAll(slaveMonitor);
    killList.add(this);

List killList=new ArrayList（）；
....
对于（int i=0；i<4；i++）{
Slave slaveThread=new Slave（）；
添加（slaveThread）；
}
killList.addAll（slaveMonitor）；
killList.add（这个）；

并使用

killList

终止线程。

1）创建一个程序，该程序使用两种类型的线程：从线程（传感器）和主线程

从线程收集测量值并将其转发给主线程

为简单起见，从机测量当前时间（System.currentTimeMillis（））。只有主线程将值输出到控制台。测量值存储在共享变量中。应从控制台读取从机的数量。

1）创建一个程序，该程序使用两种类型的线程：从机（传感器）和主线程

从线程收集测量值并将其转发给主线程

---

为了简单起见，从机测量当前时间（System.currentTimeMillis（））。只有主线程将值输出到控制台。度量值存储在一个共享变量中。应从控制台读取从属线程的数量。

这是可行的！但是，我的

killList

应该在最后一刻填充，因为我不知道有多少从属线程正在运行（slaveMonitor添加和删除线程）。如果我将最后两行放在

shutDown

thread run（）正文中，以构造

killList

，主线程不会停止。有什么想法吗？简单：创建方法addSlave，removeSlave，它对两个列表都进行操作。我不想直接使用slaveMonitor，因为它去除了意义，需要像

If>那样的测试（slaveMonitor.get（i）！=这个）做一些正常的事情。在中断之前还要检查线程是否正在运行。谢谢。我采取了在主构造函数中用
这个
填充
killList
的方法，并在发送中断信号之前，将所有从线程添加到
shutDown
线程中。如果我遇到问题，我会转向你的建议。您可能会看到我对我的方法的回答。这很有效！但是，我的
killList
应该在最后一刻填充，因为我不知道有多少从机正在运行（slaveMonitor添加和删除线程）。如果我将最后两行放入
shutDown
thread run（）主体，为了构造
killList
，主线程不会停止。有什么想法吗？很简单：创建方法addSlave，removeSlave，它对两个列表都进行操作。我不想直接使用slaveMonitor，因为它去除了含义，需要像
if（slaveMonitor.get（I）！=this）这样的测试做一些正常的事情。在中断之前还要检查线程是否正在运行。谢谢。我采取了在主构造函数中用
这个
填充
killList
的方法，并在发送中断信号之前，将所有从线程添加到
shutDown
线程中。如果我遇到问题，我会转向你的建议。你可以看到我的方法的答案。
  List<Thread> killList = new ArrayList<Thread>();
   ....
    for (int i = 0; i < 4; i++) {
        Slave slaveThread = new Slave();
        slaveMonitor.add(slaveThread);
    }
    killList.addAll(slaveMonitor);
    killList.add(this);