如何终止处于wait()状态的Java线程？附相关代码场景

针对你描述的场景——线程因调用list.wait()进入等待状态，需要通过Clock线程触发终止，这里有几个安全且符合Java规范的解决方案：

方案1：利用线程中断机制 #

Java的wait()方法会响应线程中断，抛出InterruptedException，我们可以利用这一点来终止等待的线程。

具体实现步骤： #

1. 持有等待线程的实例引用（假设你的等待线程是DepotThread）；
2. 在Clock线程的run()方法中，调用该线程的interrupt()方法；
3. 在enterramp()的catch块中，处理中断逻辑：设置终止标志并退出线程执行。

修改后的代码示例：

// 等待线程类
public class DepotThread extends Thread {
    private List<Object> list;
    private volatile boolean closingTime;

    public DepotThread(List<Object> list) {
        this.list = list;
    }

    public void run() {
        while (!closingTime) {
            enterramp();
        }
    }

    private void enterramp() {
        synchronized (list) {
            while (list.size() == 0) {
                System.out.println(":: DEPOT\t:: NO BUS FOUND IN THE APPROACHES DEPOT, WAITING THE BUS COMING");
                try {
                    list.wait();
                } catch (InterruptedException iex) {
                    // 收到中断信号，终止线程逻辑
                    closingTime = true;
                    // 可选：重新设置中断状态，让上层逻辑感知
                    Thread.currentThread().interrupt();
                    return; // 退出方法，结束循环
                }
            }
            // 原有业务处理逻辑...
        }
    }
}

// Clock线程修改
public class Clock extends Thread {
    private DepotThread depotThread;

    public Clock(DepotThread depotThread) {
        this.depotThread = depotThread;
    }

    public void run() {
        try {
            Thread.sleep(15000);
            // 触发等待线程的中断
            depotThread.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

方案2：使用volatile终止标志 + notifyAll() #

通过一个volatile修饰的标志位保证多线程可见性，结合notifyAll()唤醒等待线程，让线程醒来后主动检查标志并终止。

具体实现步骤： #

1. 定义volatile boolean stopWaiting = false;作为终止标志；
2. Clock线程中设置stopWaiting = true，然后调用list.notifyAll()唤醒所有等待在list上的线程；
3. 在enterramp()的while循环中，增加对stopWaiting的检查，一旦为true就退出执行。

修改后的代码示例：

public class DepotThread extends Thread {
    private List<Object> list;
    private volatile boolean closingTime;
    // 新增volatile终止标志
    private volatile boolean stopWaiting = false;

    public void setStopWaiting(boolean stop) {
        this.stopWaiting = stop;
    }

    // ... 其他原有代码

    private void enterramp() {
        synchronized (list) {
            // 同时检查队列状态和终止标志
            while (list.size() == 0 && !stopWaiting) {
                System.out.println(":: DEPOT\t:: NO BUS FOUND IN THE APPROACHES DEPOT, WAITING THE BUS COMING");
                try {
                    list.wait();
                } catch (InterruptedException iex) {
                    iex.printStackTrace();
                    stopWaiting = true; // 中断也触发终止
                }
            }
            // 检查终止标志，退出线程
            if (stopWaiting) {
                closingTime = true;
                return;
            }
            // 原有业务处理逻辑...
        }
    }
}

// Clock线程修改
public class Clock extends Thread {
    private DepotThread depotThread;
    private List<Object> list;

    public Clock(DepotThread depotThread, List<Object> list) {
        this.depotThread = depotThread;
        this.list = list;
    }

    public void run() {
        try {
            Thread.sleep(15000);
            depotThread.setStopWaiting(true);
            // 必须在同步块内调用notifyAll
            synchronized (list) {
                list.notifyAll();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

方案3：带超时的wait() #

将无限等待的list.wait()改为带超时的list.wait(timeout)，让线程定期醒来检查终止条件（比如closingTime），即使没有收到notify也能主动退出。

示例修改：

private void enterramp() {
    synchronized (list) {
        while (list.size() == 0 && !closingTime) {
            System.out.println(":: DEPOT\t:: NO BUS FOUND IN THE APPROACHES DEPOT, WAITING THE BUS COMING");
            try {
                list.wait(1000); // 每1秒醒来一次检查终止条件
            } catch (InterruptedException iex) {
                iex.printStackTrace();
                closingTime = true;
            }
        }
        // 原有业务处理逻辑...
    }
}

关键注意事项： #

• 绝对不要使用已废弃的Thread.stop()方法，它会强制终止线程，可能导致资源未释放、数据不一致等严重问题；
• 处理InterruptedException时，不要直接吞掉异常，要根据业务逻辑决定终止或继续执行；
• 优先使用notifyAll()而非notify()，避免因虚假唤醒或多个等待线程导致的唤醒遗漏问题。

内容的提问来源于stack exchange，提问作者Huat Lee