其他
震惊！这样终止线程，竟然会导致服务宕机？
The following article is from Java中文社群 Author 老王
脚本之家
你与百万开发者在一起
public class ThreadStopExample { public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(() -> { try { System.out.println("子线程开始执行"); // 模拟业务处理 Thread.sleep(1000); } catch (Exception e) { } // 伪代码：重要的业务方法 System.out.println("子线程的重要业务方法"); }); t1.start(); // 让子线程先运行一点业务 Thread.sleep(100); // 终止子线程 t1.stop(); // 等待一段时间，确保子线程“执行完” Thread.sleep(3000); System.out.println("主线程执行完成"); }}问题一：破坏了程序的完整性
子线程开始执行 主线程执行完成
问题二：破坏了原子逻辑
public class ThreadStopExample { public static void main(String[] args) throws InterruptedException { MyThread myThread = new MyThread(); Thread t2 = new Thread(myThread); // 开启线程 t2.start(); for (int i = 0; i < 10; i++) { Thread t = new Thread(myThread); t.start(); } // 结束线程 t2.stop(); }
/** * 自定义原子测试线程 */ static class MyThread implements Runnable { // 计数器 int num = 0;
@Override public void run() { // 同步代码块，保证原子操作 synchronized (MyThread.class) { // 自增 num++; try { // 线程休眠 0.1 秒 Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } // 自减 num--; System.out.println(Thread.currentThread().getName() + " | num=" + num); } } }}Thread-5 | num=1 Thread-4 | num=1 Thread-2 | num=1 Thread-1 | num=1 Thread-8 | num=1 Thread-6 | num=1 Thread-9 | num=1 Thread-3 | num=1 Thread-7 | num=1 Thread-10 | num=1
/** * Forces the thread to stop executing. * <p> * If there is a security manager installed, its <code>checkAccess</code> * method is called with <code>this</code> * as its argument. This may result in a * <code>SecurityException</code> being raised (in the current thread). * <p> * If this thread is different from the current thread (that is, the current * thread is trying to stop a thread other than itself), the * security manager's <code>checkPermission</code> method (with a * <code>RuntimePermission("stopThread")</code> argument) is called in * addition. * Again, this may result in throwing a * <code>SecurityException</code> (in the current thread). * <p> * The thread represented by this thread is forced to stop whatever * it is doing abnormally and to throw a newly created * <code>ThreadDeath</code> object as an exception. * <p> * It is permitted to stop a thread that has not yet been started. * If the thread is eventually started, it immediately terminates. * <p> * An application should not normally try to catch * <code>ThreadDeath</code> unless it must do some extraordinary * cleanup operation (note that the throwing of * <code>ThreadDeath</code> causes <code>finally</code> clauses of * <code>try</code> statements to be executed before the thread * officially dies). If a <code>catch</code> clause catches a * <code>ThreadDeath</code> object, it is important to rethrow the * object so that the thread actually dies. * <p> * The top-level error handler that reacts to otherwise uncaught * exceptions does not print out a message or otherwise notify the * application if the uncaught exception is an instance of * <code>ThreadDeath</code>. * * @exception SecurityException if the current thread cannot * modify this thread. * @see #interrupt() * @see #checkAccess() * @see #run() * @see #start() * @see ThreadDeath * @see ThreadGroup#uncaughtException(Thread,Throwable) * @see SecurityManager#checkAccess(Thread) * @see SecurityManager#checkPermission * @deprecated This method is inherently unsafe. Stopping a thread with * Thread.stop causes it to unlock all of the monitors that it * has locked (as a natural consequence of the unchecked * <code>ThreadDeath</code> exception propagating up the stack). If * any of the objects previously protected by these monitors were in * an inconsistent state, the damaged objects become visible to * other threads, potentially resulting in arbitrary behavior. Many * uses of <code>stop</code> should be replaced by code that simply * modifies some variable to indicate that the target thread should * stop running. The target thread should check this variable * regularly, and return from its run method in an orderly fashion * if the variable indicates that it is to stop running. If the * target thread waits for long periods (on a condition variable, * for example), the <code>interrupt</code> method should be used to * interrupt the wait. * For more information, see * <a href="{@docRoot}/../technotes/guides/concurrency/threadPrimitiveDeprecation.html">Why * are Thread.stop, Thread.suspend and Thread.resume Deprecated?</a>. */@Deprecatedpublic final void stop() { SecurityManager security = System.getSecurityManager(); if (security != null) { checkAccess(); if (this != Thread.currentThread()) { security.checkPermission(SecurityConstants.STOP_THREAD_PERMISSION); } } // A zero status value corresponds to "NEW", it can't change to // not-NEW because we hold the lock. if (threadStatus != 0) { resume(); // Wake up thread if it was suspended; no-op otherwise }
// The VM can handle all thread states stop0(new ThreadDeath());}正确终止线程
设置退出标识退出线程； 使用 interrupt() 方法终止线程。
1.自定义退出标识
// 自定义退出标识退出线程static class FlagThread extends Thread { public volatile boolean exit = false;
public void run() { while (!exit) { // 执行正常的业务逻辑 } } }2.interrupt 终止线程
public class ThreadStopExample { public static void main(String[] args) throws InterruptedException { // 问题一：破坏了程序的完整性 Thread t1 = new Thread(() -> { try { System.out.println("子线程开始执行"); // 模拟业务处理 Thread.sleep(1000); } catch (Exception e) { } // 伪代码：重要业务方法 System.out.println("子线程的重要业务方法"); }); t1.start(); // 让子线程先运行一点业务 Thread.sleep(100); // 终止子线程 t1.interrupt(); // 等待一段时间，确保子线程“执行完” Thread.sleep(3000); System.out.println("主线程执行完成");
// 问题二：破坏了原子逻辑 MyThread myThread = new MyThread(); Thread t2 = new Thread(myThread); // 开启线程 t2.start(); for (int i = 0; i < 10; i++) { Thread t = new Thread(myThread); t.start(); } // 结束线程 t2.interrupt(); }
/** * 自定义原子测试线程 */ static class MyThread implements Runnable { // 计数器 int num = 0;
@Override public void run() { // 同步代码块，保证原子操作 synchronized (MyThread.class) { // 自增 num++; try { // 线程休眠 0.1 秒 Thread.sleep(100); } catch (InterruptedException e) { System.out.println(e.getMessage()); } // 自减 num--; System.out.println(Thread.currentThread().getName() + " | num=" + num); } } }}子线程开始执行 子线程的重要业务方法 主线程执行完成 sleep interrupted Thread-1 | num=0 Thread-9 | num=0 Thread-10 | num=0 Thread-7 | num=0 Thread-6 | num=0 Thread-5 | num=0 Thread-4 | num=0 Thread-2 | num=0 Thread-3 | num=0 Thread-11 | num=0 Thread-8 | num=0
总结
更多精彩
在公众号后台对话框输入以下关键词
查看更多优质内容！
女朋友 | 大数据 | 运维 | 书单 | 算法
大数据 | JavaScript | Python | 黑客
AI | 人工智能 | 5G | 区块链
机器学习 | 数学 | 送书
●