如何为Caller类无限循环实现独立线程配合GUI启停按钮？

我来帮你搞定这个问题——你现在的核心痛点是：直接在Swing事件线程里调用Caller.call()会完全卡住GUI，导致Stop按钮根本点不动，对吧？咱们用独立工作线程+线程安全的终止逻辑就能完美解决，下面是具体的修改方案和代码解释：

问题根源 #

Swing的所有事件处理（比如按钮点击）都在**EDT（事件调度线程）**里执行，如果在actionPerformed里直接跑无限循环，EDT会被彻底阻塞，整个GUI会失去响应，Stop按钮的点击事件根本得不到处理。

解决方案思路 #

1. 把Caller的无限循环放到独立的工作线程中，不占用EDT
2. 用线程安全的方式控制循环的启动/终止（你的run变量已经加了synchronized，这点做得很好，我们再加上线程中断来实现更优雅的终止）
3. 防止多次点击Start按钮创建多个并行的工作线程

修改后的完整代码 #

1. GUI类修改（关键改动已标注） #

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class GUI implements ActionListener {
    JFrame frame;
    JPanel panel;
    JButton numberBtn;
    JLabel actNumberLabel;
    JLabel entryNumber;
    JButton startBtn;
    JButton stopBtn;
    static GUI ui;
    private boolean run = false;
    private String adminTelNumber = "006123456";
    private JTextField textEntryNumber;
    // 新增：保存工作线程实例，防止重复启动
    private Thread workerThread;

    public GUI() {
        frame = new JFrame("Caller GUI");
        frame.getContentPane().setLayout(null);
        frame.setPreferredSize(new Dimension(400,300));
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JPanel panel_1 = new JPanel();
        panel_1.setBounds(0, 0, 434, 70);
        frame.getContentPane().add(panel_1);
        panel_1.setLayout(null);

        startBtn = new JButton("Start");
        startBtn.setBounds(274, 11, 89, 23);
        startBtn.addActionListener(this);
        panel_1.add(startBtn);

        stopBtn = new JButton("Stop");
        stopBtn.setBounds(274, 36, 89, 23);
        stopBtn.addActionListener(this);
        panel_1.add(stopBtn);

        JPanel panel_2 = new JPanel();
        panel_2.setBounds(0, 70, 434, 120);
        frame.getContentPane().add(panel_2);
        panel_2.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 5));

        JPanel panel_3 = new JPanel();
        panel_3.setBounds(0, 190, 434, 71);
        frame.getContentPane().add(panel_3);
        panel_3.setLayout(null);

        JLabel entryNumber = new JLabel("Telefonnummer eingeben:");
        entryNumber.setBounds(10, 11, 183, 14);
        panel_3.add(entryNumber);

        textEntryNumber = new JTextField();
        textEntryNumber.setBounds(10, 25, 112, 20);
        panel_3.add(textEntryNumber);
        textEntryNumber.setColumns(10);

        numberBtn = new JButton("Übernehmen");
        numberBtn.setBounds(132, 24, 107, 23);
        numberBtn.addActionListener(this);
        panel_3.add(numberBtn);

        actNumberLabel = new JLabel("Derzeitige Signalisierung auf: " + adminTelNumber);
        actNumberLabel.setBounds(10, 46, 369, 14);
        panel_3.add(actNumberLabel);

        frame.pack();
        frame.setVisible(true);
    }

    @Override
    public synchronized void actionPerformed(ActionEvent e) {
        if(e.getSource() == numberBtn){
            adminTelNumber = textEntryNumber.getText();
            actNumberLabel.setText("Derzeitige Signalisierung auf: " + adminTelNumber);
            textEntryNumber.setText("");
        }
        if(e.getSource() == startBtn) {
            // 关键：检查线程是否已存活，避免重复启动多个工作线程
            if (workerThread == null || !workerThread.isAlive()) {
                run = true;
                // 创建并启动工作线程
                workerThread = new Thread(() -> {
                    Caller.call(ui, 90000, 45);
                    // 线程结束后重置实例，允许下次启动
                    workerThread = null;
                });
                workerThread.start();
            }
        }
        if(e.getSource() == stopBtn) {
            run = false;
            // 关键：中断线程，让sleep提前唤醒，快速响应停止操作
            if (workerThread != null && workerThread.isAlive()) {
                workerThread.interrupt();
            }
        }
    }

    public synchronized String getAdminTelNumber() {
        return adminTelNumber;
    }

    public synchronized boolean getRun() {
        return run;
    }

    public static void main(String[] args) {
        try {
            ui = new GUI();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2. Caller类修改（关键改动已标注） #

import java.util.ArrayList;

public class Caller {
    static String number = null;

    public static void call(GUI ui, int sleepTime, int standardLeadTime) {
        ArrayList<Integer> alarmTaskIdList = new ArrayList<Integer>();
        ArrayList<Integer> doneTasksList = new ArrayList<Integer>();
        ArrayList<Integer> doneAlarmTasksList = new ArrayList<Integer>();
        ArrayList<Integer> taskIdList = new ArrayList<Integer>();

        // 关键：同时检查run状态和线程中断状态，保证能快速终止
        while (ui.getRun() && !Thread.currentThread().isInterrupted()) {
            doneTasksList = wakeUpCall(taskIdList, doneTasksList, standardLeadTime);
            doneAlarmTasksList = alarmCall(alarmTaskIdList, doneAlarmTasksList, ui);

            try {
                Thread.sleep(sleepTime);
            } catch (InterruptedException e) {
                // 捕获中断后重置中断状态，确保线程能正常退出
                Thread.currentThread().interrupt();
                break;
            }
        }
    }

    // 这里补充你原本的wakeUpCall和alarmCall实现
    private static ArrayList<Integer> wakeUpCall(ArrayList<Integer> taskIdList, ArrayList<Integer> doneTasksList, int standardLeadTime) {
        // 你的业务逻辑
        return doneTasksList;
    }

    private static ArrayList<Integer> alarmCall(ArrayList<Integer> alarmTaskIdList, ArrayList<Integer> doneAlarmTasksList, GUI ui) {
        // 你的业务逻辑
        return doneAlarmTasksList;
    }
}

关键改动说明 #

1. 工作线程隔离：把Caller.call()放到独立Thread中执行，彻底解放EDT，保证GUI始终响应
2. 防止重复启动：通过workerThread实例检查，避免多次点击Start创建多个并行线程
3. 优雅终止：调用workerThread.interrupt()让Thread.sleep()提前抛出异常，不用等sleep时间结束就能停止循环
4. 线程安全：run变量通过synchronized方法访问，保证多线程下的状态可见性

额外注意事项 #

如果wakeUpCall或alarmCall是耗时操作，建议在这些方法内部也定期检查ui.getRun()或线程中断状态，避免这些方法阻塞导致无法及时响应Stop指令。

内容的提问来源于stack exchange，提问作者D.Schall