在 java 线程创建与运行中,stop() 方法已被废弃且极不安全,因为它会强制终止线程并释放所有锁,导致数据不一致;而 interrupt() 是推荐的协作式中断机制,它仅设置线程的中断标志位,由线程自行检查标志并安全退出。开发者应使用 interrupt() 配合 isinterrupted() 或捕获 interruptedexception 来实现线程的优雅停止。

stop() 为何会导致数据不一致和锁过早释放?
stop() 方法会立即强行终止目标线程,无论该线程当前执行到哪一步。这种粗暴的行为会导致两个主要问题:一是如果线程正在持有某个监视器锁(Monitor Lock),一旦线程被杀死,该锁会被立即释放,其他等待该锁的线程可以继续执行,但它们可能看到处于中间状态、未完全更新的数据;二是线程不会执行后续的清理代码(如 finally 块中的资源释放逻辑),可能导致文件句柄泄露或数据库连接未关闭等后果。

import java.util.concurrent.locks.ReentrantLock;
public class UnsafeStopExample {
private static final ReentrantLock lock = new ReentrantLock();
private static int sharedData = 0;
public static void main(String[] args) throws InterruptedException {
Thread writer = new Thread(() -> {
lock.lock();
try {
// 模拟一个需要原子性的操作:先读取,再修改,再写入
int temp = sharedData;
temp = temp + 1;
// 这里故意休眠,让 stop() 有机会在赋值前介入
try { Thread.sleep(100); } catch (InterruptedException e) {}
sharedData = temp;
System.out.println("Writer finished: " + sharedData);
} finally {
lock.unlock();
}
});
writer.start();
Thread.sleep(50); // 确保 writer 进入临界区
// 强制停止线程,即使它正持有锁
writer.stop();
// 主线程尝试获取锁并读取数据
lock.lock();
try {
System.out.println("Main read data: " + sharedData);
} finally {
lock.unlock();
}
}
}
在上述代码中,writer.stop() 调用后,writer 线程立即死亡。虽然 ReentrantLock 的 unlock() 在 finally 块中,但由于线程被强制终止,JVM 可能会直接回收线程资源而不执行 finally,或者更糟糕的是,如果使用的是内置锁 synchronized,锁会被强制释放。即便锁被正确释放,sharedData 的值可能只完成了部分更新,或者因为线程突然消失而导致后续依赖该数据的逻辑出错。这就是为什么 stop() 被视为“毒药”的原因。
interrupt() 如何触发 InterruptedException 并实现安全退出?
interrupt() 方法的作用是向目标线程发送一个中断信号,即设置其内部的中断标志位为 true。如果目标线程当前正处于阻塞状态(例如调用了 Thread.sleep()、Object.wait() 或 LockSupport.park()),它会立即抛出 InterruptedException。开发者需要在 catch 块中处理这个异常,通常的做法是恢复中断状态(Thread.currentThread().interrupt())并跳出循环或返回,从而让线程安全地结束运行。对于非阻塞的代码段,可以通过轮询 Thread.interrupted() 或 isInterrupted() 来主动检查是否收到中断请求。

import java.util.concurrent.locks.ReentrantLock;
public class SafeInterruptExample {
private static final ReentrantLock lock = new ReentrantLock();
private static int sharedData = 0;
public static void main(String[] args) throws InterruptedException {
Thread worker = new Thread(() -> {
while (!Thread.currentThread().isInterrupted()) {
if (lock.tryLock()) {
try {
int temp = sharedData;
temp = temp + 1;
sharedData = temp;
System.out.println("Worker updated data to: " + sharedData);
} finally {
lock.unlock();
}
}
try {
// 如果线程被中断,sleep 会抛出 InterruptedException
Thread.sleep(1000);
} catch (InterruptedException e) {
// 恢复中断状态,以便外层或上层能感知到中断
Thread.currentThread().interrupt();
break; // 安全退出循环
}
}
System.out.println("Worker exited safely.");
});
worker.start();
Thread.sleep(2500); // 等待一段时间
// 发送中断信号
worker.interrupt();
worker.join(); // 等待线程正常结束
System.out.println("Final data: " + sharedData);
}
}
在这个安全的示例中,worker.interrupt() 并没有立即杀死线程,而是设置了中断标志。当线程执行到 Thread.sleep(1000) 时,由于检测到中断标志,它抛出了 InterruptedException。我们在 catch 块中恢复了中断状态并 break 出循环,确保了线程能够执行完必要的清理工作(如果有的话)并正常退出。这种方式保证了共享数据 sharedData 的完整性,因为每次修改都在锁的保护下完成,并且线程是在锁释放后才退出的。
如果线程没有调用阻塞方法,interrupt() 还能让它停下来吗?
如果线程没有调用任何会抛出 InterruptedException 的阻塞方法,interrupt() 仅仅会将线程的中断标志位设置为 true,而不会自动停止线程的执行。这意味着线程会继续运行下去,除非代码显式地检查这个标志位。因此,在编写长时间运行的非阻塞任务(如复杂的计算循环)时,必须手动添加对 Thread.interrupted() 或 isInterrupted() 的检查。如果不进行检查,中断信号将被忽略,线程将继续执行直到自然结束,这违背了中断的初衷。
Java免费学习笔记:立即使用
解锁 Java 大师之旅:从入门到精通的终极指南











