07_线程停止(interrupt,interrupted,isInterrupted)

最新推荐文章于 2025-02-28 00:15:00 发布
最新推荐文章于 2025-02-28 00:15:00 发布
阅读量235 收藏
点赞数 1
分类专栏： Java 多线程编程核心技术 文章标签： java 线程
本文详细介绍了Java中线程的启动方式，包括通过继承Thread类和实现Runnable接口两种方法，并深入探讨了线程的停止机制，如使用interrupt()方法、异常法、sleep()方法等不同的停止策略。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >





一. 线程启动




线程启动 : 

– 1. 继承 Thread 运行线程 : 重写 Thread 类的 run 方法, 然后执行该线程;

– 2. 实现 Runnable 接口, 并运行线程;

– 代码示例 : 

[java] view plain copy
print ?
  1. package com.hanshuliang.thread;  
  2.   
  3. public class ThreadStart {  
  4.   
  5.     public static void main(String[] args) {  
  6.         //1. 继承 Thread 运行线程  
  7.         MyThread thread = new MyThread();  
  8.         thread.start();  
  9.           
  10.         //2. 实现 Runnable 接口, 并运行线程  
  11.         Thread runnableThread = new Thread(new MyRunnable());  
  12.         runnableThread.start();  
  13.     }  
  14.       
  15.     //1. 继承 Thread 类  
  16.     static class MyThread extends Thread{  
  17.         @Override  
  18.         public void run() {  
  19.             super.run();  
  20.             System.out.println(”MyThread 线程启动”);  
  21.         }  
  22.     }  
  23.       
  24.     //2. 实现 Runnable 接口  
  25.     static class MyRunnable implements Runnable{  
  26.         @Override  
  27.         public void run() {  
  28.             System.out.println(”MyRunnable 线程启动”);  
  29.         }  
  30.     }  
  31. }  
package com.hanshuliang.thread;

public class ThreadStart {

    public static void main(String[] args) {
        //1. 继承 Thread 运行线程
        MyThread thread = new MyThread();
        thread.start();

        //2. 实现 Runnable 接口, 并运行线程
        Thread runnableThread = new Thread(new MyRunnable());
        runnableThread.start();
    }

    //1. 继承 Thread 类
    static class MyThread extends Thread{
        @Override
        public void run() {
            super.run();
            System.out.println("MyThread 线程启动");
        }
    }

    //2. 实现 Runnable 接口
    static class MyRunnable implements Runnable{
        @Override
        public void run() {
            System.out.println("MyRunnable 线程启动");
        }
    }
}


– 运行结果 : 

[java] view plain copy
print ?
  1. MyThread 线程启动  
  2. MyRunnable 线程启动  
MyThread 线程启动
MyRunnable 线程启动




三. 线程停止



线程停止常用方法 : 

– 1. 使用 interrupt() 方法停止线程;

– 2. 使用退出标志, 让线程正常退出;

– 3. 弃用的方法 (不推荐) : 使用 stop() 方法强制停止线程, 但是该方法已经作废, 不建议使用;


1. 使用 interrupt() 方法停止线程


(1) 线程无法立即停止



interrupt() 使用说明 : 

– 打标记 : 调用该方法, 不能马上停止该线程, 只是在当前线程打了一个停止标记;


代码示例 : 

– 代码 : 

[java] view plain copy
print ?
  1. public class InterruptDemo {  
  2.     public static class MyThread extends Thread {  
  3.         @Override  
  4.         public void run() {  
  5.             super.run();  
  6.             for (int i = 1; i <= 1000000; i++)   //打印 一百万 数字, 大概持续 5 ~ 10 秒左右  
  7.                 System.out.println(i);  
  8.         }  
  9.     }  
  10.     public static void main(String[] args) throws InterruptedException {  
  11.         MyThread thread = new MyThread();  
  12.         thread.start();                     //启动线程  
  13.         Thread.sleep(100);                  //启动线程 100ms 后中断线程  
  14.         thread.interrupt();                 //中断线程  
  15.     }  
  16. }  
public class InterruptDemo {
    public static class MyThread extends Thread {
        @Override
        public void run() {
            super.run();
            for (int i = 1; i <= 1000000; i++)   //打印 一百万 数字, 大概持续 5 ~ 10 秒左右
                System.out.println(i);
        }
    }
    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();
        thread.start();                     //启动线程
        Thread.sleep(100);                  //启动线程 100ms 后中断线程
        thread.interrupt();                 //中断线程
    }
}


– 运行结果 : 这里只贴上最后几行 命令行的运行结果;

[plain] view plain copy
print ?
  1. … …  
  2. 999996  
  3. 999997  
  4. 999998  
  5. 999999  
  6. 1000000  
... ...
999996
999997
999998
999999
1000000


– 总结 : 在上述程序中, 打印了 100 万数字, 从 1 到 100 0000, 整个过程持续了 10秒左右, 但是我们在 线程开始后 100ms 就中断了线程, 但是线程还是执行完毕了, 说明线程并没有在调用 interrupt() 方法后立即停止;




(2) 线程停止状态判定



两个线程停止状态判定的方法 : 

– 1. interrupted() 方法 : ①判断当前线程的中断标志, ②如果是中断标志 true, 那么清除中断标志, 改为 false;,③ 连续两次调用该方法, 第二次返回 false, ④ 静态方法 : 该方法是测试当前线程的中断标志, 在哪个线程中调用, 就是判定的哪个线程的中断标志, 不管调用的主体是哪个线程;

– 2. isInterrupted() 方法 : 判断线程的 中断状态, 不管真实的运行状态, 只关心状态;

– 注意 : 两个方法都是判断 中断状态的, 与线程的真实运行状况无关;



(3) interrupted() 方法测试



interrupted () 方法测试1 : 测试 interrupted 方法的判断是否已经中断的效果;

– 测试代码 : 

[java] view plain copy
print ?
  1. public class InterruptedDemo1 {  
  2.     public static class MyThread extends Thread {  
  3.         @Override  
  4.         public void run() {  
  5.             super.run();  
  6.             for (int i = 1; i <= 10; i++)    //打印10个数字  
  7.                 System.out.println(i);  
  8.         }  
  9.     }  
  10.     public static void main(String[] args) throws InterruptedException {  
  11.         MyThread thread = new MyThread();  
  12.         thread.start();                     //启动线程  
  13.         thread.interrupt();                 //启动线程后马上 中断线程  
  14.           
  15.         System.out.println(”第一次 : thread.interrupted() = ” + thread.interrupted());  
  16.         System.out.println(”第二次 : thread.interrupted() = ” + thread.interrupted());  
  17.     }  
  18. }  
public class InterruptedDemo1 {
    public static class MyThread extends Thread {
        @Override
        public void run() {
            super.run();
            for (int i = 1; i <= 10; i++)    //打印10个数字
                System.out.println(i);
        }
    }
    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();
        thread.start();                     //启动线程
        thread.interrupt();                 //启动线程后马上 中断线程

        System.out.println("第一次 : thread.interrupted() = " + thread.interrupted());
        System.out.println("第二次 : thread.interrupted() = " + thread.interrupted());
    }
}


– 执行结果 : 

[plain] view plain copy
print ?
  1. 第一次 : thread.interrupted() = false  
  2. 1  
  3. 2  
  4. 第二次 : thread.interrupted() = false  
  5. 3  
  6. 4  
  7. 5  
  8. 6  
  9. 7  
  10. 8  
  11. 9  
  12. 10  
第一次 : thread.interrupted() = false
1
2
第二次 : thread.interrupted() = false
3
4
5
6
7
8
9
10


– 总结 : 启动线程后, 立即调用 interrupt 方法 中断线程, 但是 在主线程中 调用 thread.Interrupted() 方法, 打印出来的是 主线程的中断状态标志, 虽然是调用的 thread 子线程的对象的方法, 但是该方法是一个静态方法, 在哪个线程调用, 就是打印哪个线程的中断标志;



interrupted () 方法测试2 : 测试 interrupted 方法的 清除 中断状态 的效果;

– 1. 测试代码 : 

[java] view plain copy
print ?
  1. public class InterruptedDemo {  
  2.     public static void main(String[] args) throws InterruptedException {  
  3.         Thread.currentThread().interrupt();     //中断主线程  
  4.           
  5.         System.out.println(”第一次 : thread.interrupted() = ” + Thread.interrupted());  
  6.         System.out.println(”第二次 : thread.interrupted() = ” + Thread.interrupted());  
  7.     }  
  8. }  
public class InterruptedDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread.currentThread().interrupt();     //中断主线程

        System.out.println("第一次 : thread.interrupted() = " + Thread.interrupted());
        System.out.println("第二次 : thread.interrupted() = " + Thread.interrupted());
    }
}


– 2. 执行结果 : 

[java] view plain copy
print ?
  1. 第一次 : thread.interrupted() = true  
  2. 第二次 : thread.interrupted() = false  
第一次 : thread.interrupted() = true
第二次 : thread.interrupted() = false


– 3. 总结 : 使用 interrupted() 方法, 如果当前线程的状态是中断状态, 即返回了 true, 那么需要清除该标志, 下一次调用 interrupted() 方法后, 返回值就是 false 了;



(4) isInterrupted() 方法测试



isInterrupted() 方法测试1 : 测试其 中断状态, 与上面的 interrupted() 方法对比;

– 1. 测试代码 : 

[java] view plain copy
print ?
  1. public class IsInterruptedDemo {  
  2.     public static class MyThread extends Thread {  
  3.         @Override  
  4.         public void run() {  
  5.             super.run();  
  6.             for (int i = 1; i <= 10; i++)    //打印10个数字  
  7.                 System.out.println(i);  
  8.         }  
  9.     }  
  10.     public static void main(String[] args) throws InterruptedException {  
  11.         MyThread thread = new MyThread();  
  12.         thread.start();                     //启动线程  
  13.         thread.interrupt();                 //启动线程后马上 中断线程  
  14.           
  15.         System.out.println(”第一次 : thread.interrupted() = ” + thread.isInterrupted());  
  16.         System.out.println(”第二次 : thread.interrupted() = ” + thread.isInterrupted());  
  17.     }  
  18. }  
public class IsInterruptedDemo {
    public static class MyThread extends Thread {
        @Override
        public void run() {
            super.run();
            for (int i = 1; i <= 10; i++)    //打印10个数字
                System.out.println(i);
        }
    }
    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();
        thread.start();                     //启动线程
        thread.interrupt();                 //启动线程后马上 中断线程

        System.out.println("第一次 : thread.interrupted() = " + thread.isInterrupted());
        System.out.println("第二次 : thread.interrupted() = " + thread.isInterrupted());
    }
}


– 2. 返回值 : 

[java] view plain copy
print ?
  1. 第一次 : thread.interrupted() = true  
  2. 1  
  3. 2  
  4. 第二次 : thread.interrupted() = true  
  5. 3  
  6. 4  
  7. 5  
  8. 6  
  9. 7  
  10. 8  
  11. 9  
  12. 10  
第一次 : thread.interrupted() = true
1
2
第二次 : thread.interrupted() = true
3
4
5
6
7
8
9
10


– 3. 总结分析 : isInterrupted() 方法 只 判断 被调用对象的 该对象线程的 线程的中断 状态, 不管线程的真实运行状况, 即使当前线程正在运行, 但是线程调用了 interrupt() 方法, 其中断状态为 true, 因此 isInterrupted() 方法的返回值一直是 true;

– 4. 对比 interrupted() 方法 : interrupted() 方法反应的是真实的线程运行状态, 线程正在运行, 那么返回 false, 如果线程没有运行, 返回 true;

– 5. 对比 Interrupted() 方法 (静态与普通方法) : isInterrupted 方法是非静态方法, 哪个对象调用返回的就是哪个对象的中断状态; interrupted 是静态方法, 在哪个线程调用就是返回哪个线程的中断状态;




2. 异常法停止线程


(1) 线程循环中正常退出停止



退出方法 : 正常退出线程;

– 1. 前提 : 线程中执行一个循环;

– 2. 中断线程 : 执行线程中断操作, 调用 线程的 interrupt() 方法;

– 3. 查询中断标志 : 在线程中通过调用 interrupted 方法, 查询当前的线程中断标志, 之后该方法就会将中断标志清除;

– 4. 退出循环 : 如果查询到中断标志后, 直接使用 break 退出循环;

– 5. 弊端 : 在线程中, 线程没有真正的停止, 线程还是完整的执行了;


线程正常退出代码示例 : 

– 1. 代码 : 

[java] view plain copy
print ?
  1. public class ExceptionInterruptDeo {  
  2.     public static class MyThread extends Thread{  
  3.         @Override  
  4.         public void run() {  
  5.             super.run();  
  6.             for(int i = 0; i < 500; i ++){  
  7.                 if(interrupted()){              //判断线程的中断状态, 如果中断直接 break  
  8.                     System.out.println(”停止状态, 退出”);  
  9.                     break;  
  10.                 }  
  11.                 System.out.println(i);  
  12.             }  
  13.             System.out.println(”MyThread 线程执行完毕”);//线程结束标志  
  14.         }  
  15.     }  
  16.     public static void main(String[] args) throws InterruptedException {  
  17.         MyThread thread = new MyThread();       //创建线程并执行  
  18.         thread.start();                         //启动线程  
  19.         Thread.sleep(1);                        //沉睡 1 毫秒  
  20.         thread.interrupt();                     //中断线程  
  21.         System.out.println(”主线程执行完毕”);  //判断主线程停止  
  22.     }  
  23. }  
public class ExceptionInterruptDeo {
    public static class MyThread extends Thread{
        @Override
        public void run() {
            super.run();
            for(int i = 0; i < 500; i ++){
                if(interrupted()){              //判断线程的中断状态, 如果中断直接 break
                    System.out.println("停止状态, 退出");
                    break;
                }
                System.out.println(i);
            }
            System.out.println("MyThread 线程执行完毕");//线程结束标志
        }
    }
    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();       //创建线程并执行
        thread.start();                         //启动线程
        Thread.sleep(1);                        //沉睡 1 毫秒
        thread.interrupt();                     //中断线程
        System.out.println("主线程执行完毕");  //判断主线程停止
    }
}


– 2. 执行结果 : 

[java] view plain copy
print ?
  1. … …  
  2. 50  
  3. 51  
  4. 52  
  5. 53  
  6. 54  
  7. 主线程执行完毕  
  8. 停止状态, 退出  
  9. MyThread 线程执行完毕  
... ...
50
51
52
53
54
主线程执行完毕
停止状态, 退出
MyThread 线程执行完毕


– 3. 总结分析 : 在线程中调用 interrupted() 方法, 查询中断标志(查询后立即清除中断标志), 弊端是停止线程后, 线程还是继续执行后面的逻辑, 继续执行完毕, 自动退出的;



(2) 异常退出线程



异常法退出线程 : 通过抛出一个异常, 来终止线程执行;

– 1. 前提 : 线程中执行一个循环;

– 2. 中断线程 : 执行线程中断操作, 调用 线程的 interrupt() 方法;

– 3. 查询中断标志 : 在线程中通过调用 interrupted 方法, 查询当前的线程中断标志, 之后该方法就会将中断标志清除;

– 4. 抛出异常退出循环 : 如果查询到中断标志后, 直接抛出一个 InterruptException 异常;

– 5. 捕获处理异常 : 要将整个 run 方法中的内容使用 try catch 代码块捕获, 因因为异常捕获后还会继续处理 try catch 之后的代码逻辑, 如果 try catch 代码块之后还有代码逻辑, 程序还会执行这段代码;

– 6. 好处 : 可以自由控制要中断哪些逻辑;


异常捕获规则 : 

– 1. 执行逻辑 : 捕获异常后, 进行异常处理, 然后会继续执行 try catch 代码块 后面的代码逻辑;

– 2. 异常退出范围可控 : 可以自由控制中断哪些操作, 继续执行哪些操作;


代码测试 : 

– 1. 代码 : 

[java] view plain copy
print ?
  1. public class ExceptionInterruptDeo {  
  2.     public static class MyThread extends Thread {  
  3.         @Override  
  4.         public void run() {  
  5.             try {  
  6.                 super.run();  
  7.                 for (int i = 0; i < 500; i++) {  
  8.                     if (interrupted()) { // 判断线程的中断状态, 如果中断直接 break  
  9.                         System.out.println(”停止状态, 抛出异常退出”);  
  10.                         throw new InterruptedException();  
  11.                     }// 中断标志 判定结束  
  12.                     System.out.println(i);  
  13.                 }//for 循环结束  
  14.                 System.out.println(”MyThread 线程执行完毕”);// 线程结束标志  
  15.             } catch (InterruptedException e) {  
  16.                 System.out.println(”线程中捕获异常代码块”);  
  17.                 e.printStackTrace();  
  18.             } // try catch 代码块  
  19.         }//run方法结束  
  20.     }//线程结束  
  21.   
  22.     public static void main(String[] args) throws InterruptedException {  
  23.         MyThread thread = new MyThread(); // 创建线程并执行  
  24.         thread.start(); // 启动线程  
  25.         Thread.sleep(1); // 沉睡 1 毫秒  
  26.         thread.interrupt(); // 中断线程  
  27.         System.out.println(”主线程执行完毕”); // 判断主线程停止  
  28.     }  
  29. }  
public class ExceptionInterruptDeo {
    public static class MyThread extends Thread {
        @Override
        public void run() {
            try {
                super.run();
                for (int i = 0; i < 500; i++) {
                    if (interrupted()) { // 判断线程的中断状态, 如果中断直接 break
                        System.out.println("停止状态, 抛出异常退出");
                        throw new InterruptedException();
                    }// 中断标志 判定结束
                    System.out.println(i);
                }//for 循环结束
                System.out.println("MyThread 线程执行完毕");// 线程结束标志
            } catch (InterruptedException e) {
                System.out.println("线程中捕获异常代码块");
                e.printStackTrace();
            } // try catch 代码块
        }//run方法结束
    }//线程结束

    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread(); // 创建线程并执行
        thread.start(); // 启动线程
        Thread.sleep(1); // 沉睡 1 毫秒
        thread.interrupt(); // 中断线程
        System.out.println("主线程执行完毕"); // 判断主线程停止
    }
}


– 2. 执行结果 : 

[java] view plain copy
print ?
  1. 113  
  2. 114  
  3. 115  
  4. 116  
  5. 主线程执行完毕  
  6. 停止状态, 抛出异常退出  
  7. 线程中捕获异常代码块  
  8. java.lang.InterruptedException  
  9.     at base.ExceptionInterruptDeo$MyThread.run(ExceptionInterruptDeo.java:12)  
113
114
115
116
主线程执行完毕
停止状态, 抛出异常退出
线程中捕获异常代码块
java.lang.InterruptedException
    at base.ExceptionInterruptDeo$MyThread.run(ExceptionInterruptDeo.java:12)


– 3. 总结分析 : 在 run 方法中将整个代码逻辑使用 try catch 代码块包裹, 异常法只能中断 try catch 代码块中的逻辑;




3. sleep() 中停止线程


(1) 先沉睡在终止线程



先 sleep() 再 interrupt() : 先沉睡, 再终止线程, 线程直接就停止了;


代码示例 : 

– 1. 代码 : 

[java] view plain copy
print ?
  1. public class SleepInterruptDemo {  
  2.     public static class MyThread extends Thread{  
  3.         @Override  
  4.         public void run() {  
  5.             try {  
  6.                 System.out.println(”线程逻辑开始”);  
  7.                 super.run();  
  8.                 sleep(1000);    //启动后立即进入沉睡状态, 沉睡 1000ms  
  9.                 System.out.println(”线程逻辑结束”);  
  10.             } catch (InterruptedException e) {  
  11.                 System.out.println(”捕获到了异常 , 进入了 catch 代码块”);  
  12.                 e.printStackTrace();  
  13.             }//catch代码块  
  14.             System.out.println(”run 方法结束”);  
  15.         }//run方法  
  16.     }//线程  
  17.       
  18.     public static void main(String[] args) throws InterruptedException {  
  19.         MyThread thread = new MyThread();   //新建线程  
  20.         thread.start();                     //线程启动  
  21.         Thread.sleep(100);                  //沉睡 100 毫秒, 线程中  
  22.         thread.interrupt();                 //中断线程  
  23.     }  
  24. }  
public class SleepInterruptDemo {
    public static class MyThread extends Thread{
        @Override
        public void run() {
            try {
                System.out.println("线程逻辑开始");
                super.run();
                sleep(1000);    //启动后立即进入沉睡状态, 沉睡 1000ms
                System.out.println("线程逻辑结束");
            } catch (InterruptedException e) {
                System.out.println("捕获到了异常 , 进入了 catch 代码块");
                e.printStackTrace();
            }//catch代码块
            System.out.println("run 方法结束");
        }//run方法
    }//线程

    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();   //新建线程
        thread.start();                     //线程启动
        Thread.sleep(100);                  //沉睡 100 毫秒, 线程中
        thread.interrupt();                 //中断线程
    }
}


– 2. 执行结果 : 

[java] view plain copy
print ?
  1. 线程逻辑开始  
  2. 捕获到了异常 , 进入了 catch 代码块  
  3. run 方法结束  
  4. java.lang.InterruptedException: sleep interrupted  
  5.     at java.lang.Thread.sleep(Native Method)  
  6.     at base.SleepInterruptDemo$MyThread.run(SleepInterruptDemo.java:11)  
线程逻辑开始
捕获到了异常 , 进入了 catch 代码块
run 方法结束
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at base.SleepInterruptDemo$MyThread.run(SleepInterruptDemo.java:11)


– 3. 总结分析 : 在沉睡状态下, 如果调用 interrupt() 方法, 线程中会直接抛出 InterruptException 异常;



(2) 先终止线程 再 沉睡



先 终止线程 再 sleep : 先 终止线程, 在 sleep, 那么 sleep 之前的代码需要实现相关逻辑


代码示例 : 

– 1. 代码 : 与上面的区别是 在 sleep 之前有一段 循环逻辑;

[java] view plain copy
print ?
  1. public class SleepInterruptDemo {  
  2.     public static class MyThread extends Thread{  
  3.         @Override  
  4.         public void run() {  
  5.             try {  
  6.                 System.out.println(”线程逻辑开始”);  
  7.                 super.run();  
  8.                 for(int i = 0; i < 500; i ++)  
  9.                     System.out.println(i);  
  10.                 sleep(1000);    //启动后立即进入沉睡状态, 沉睡 1000ms  
  11.                 System.out.println(”线程逻辑结束”);  
  12.             } catch (InterruptedException e) {  
  13.                 System.out.println(”捕获到了异常 , 进入了 catch 代码块”);  
  14.                 e.printStackTrace();  
  15.             }//catch代码块  
  16.             System.out.println(”run 方法结束”);  
  17.         }//run方法  
  18.     }//线程  
  19.       
  20.     public static void main(String[] args) throws InterruptedException {  
  21.         MyThread thread = new MyThread();   //新建线程  
  22.         thread.start();                     //线程启动  
  23.         thread.interrupt();                 //中断线程  
  24.         System.out.println(”主线程中断线程”);  
  25.     }  
  26. }  
public class SleepInterruptDemo {
    public static class MyThread extends Thread{
        @Override
        public void run() {
            try {
                System.out.println("线程逻辑开始");
                super.run();
                for(int i = 0; i < 500; i ++)
                    System.out.println(i);
                sleep(1000);    //启动后立即进入沉睡状态, 沉睡 1000ms
                System.out.println("线程逻辑结束");
            } catch (InterruptedException e) {
                System.out.println("捕获到了异常 , 进入了 catch 代码块");
                e.printStackTrace();
            }//catch代码块
            System.out.println("run 方法结束");
        }//run方法
    }//线程

    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();   //新建线程
        thread.start();                     //线程启动
        thread.interrupt();                 //中断线程
        System.out.println("主线程中断线程");
    }
}


– 2. 执行结果 : 

[java] view plain copy
print ?
  1. 496  
  2. 497  
  3. 498  
  4. 499  
  5. 捕获到了异常 , 进入了 catch 代码块  
  6. run 方法结束  
  7. java.lang.InterruptedException: sleep interrupted  
  8.     at java.lang.Thread.sleep(Native Method)  
  9.     at base.SleepInterruptDemo$MyThread.run(SleepInterruptDemo.java:12)  
496
497
498
499
捕获到了异常 , 进入了 catch 代码块
run 方法结束
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at base.SleepInterruptDemo$MyThread.run(SleepInterruptDemo.java:12)


– 3. 总结 : 使用 Interrupt 方法后, 如果正在执行循环, 就不会抛异常退出线程, 进入 sleep 状态后, 会立即抛出异常, 退出线程;





4. stop() 停止线程


(1) stop 方法停止线程的效果



stop 停止线程 : 

– 1. 立即停止 : 调用 stop() 方法停止线程, 比较暴力, 会立即停止当前的线程;

– 2. 抛出异常 : 使用 stop() 方法停止线程会抛出一个 ThreadDeath 异常, 这个异常可以不捕捉;

– 3. 适用场景 : 适用该方法停止线程, 前提示 线程的相关数据 和 线程本身 都不再使用了, 否则会造成数据混乱;


stop() 停止线程效果演示 : 

– 1. 代码示例 : 

[java] view plain copy
print ?
  1. public class StopDemo {  
  2.     public static class MyThread extends Thread{  
  3.         @Override  
  4.         public void run() {  
  5.             try {  
  6.                 System.out.println(”线程逻辑开始”);  
  7.                 super.run();  
  8.                 for(int i = 0; i < 5000; i ++){  
  9.                     System.out.println(i);  
  10.                     sleep(100);   
  11.                 }  
  12.                 System.out.println(”线程逻辑结束”);  
  13.             } catch (InterruptedException e) {  
  14.                 System.out.println(”捕获到了 InterruptedException 异常 , 进入了 catch 代码块”);  
  15.                 e.printStackTrace();  
  16.             }//catch代码块  
  17.             System.out.println(”run 方法结束”);  
  18.         }//run方法  
  19.     }//线程  
  20.       
  21.     public static void main(String[] args) throws InterruptedException {  
  22.         MyThread thread = new MyThread();   //新建线程  
  23.         thread.start();                     //线程启动  
  24.         Thread.sleep(500);                  //沉睡 500ms, 让线程打印 5 个数字  
  25.         thread.stop();                      //中断线程  
  26.         System.out.println(”主线程中断线程”);  
  27.     }  
  28. }  
public class StopDemo {
    public static class MyThread extends Thread{
        @Override
        public void run() {
            try {
                System.out.println("线程逻辑开始");
                super.run();
                for(int i = 0; i < 5000; i ++){
                    System.out.println(i);
                    sleep(100); 
                }
                System.out.println("线程逻辑结束");
            } catch (InterruptedException e) {
                System.out.println("捕获到了 InterruptedException 异常 , 进入了 catch 代码块");
                e.printStackTrace();
            }//catch代码块
            System.out.println("run 方法结束");
        }//run方法
    }//线程

    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();   //新建线程
        thread.start();                     //线程启动
        Thread.sleep(500);                  //沉睡 500ms, 让线程打印 5 个数字
        thread.stop();                      //中断线程
        System.out.println("主线程中断线程");
    }
}


– 2. 运行结果 : 

[java] view plain copy
print ?
  1. 线程逻辑开始  
  2. 0  
  3. 1  
  4. 2  
  5. 3  
  6. 4  
  7. 主线程中断线程  
线程逻辑开始
0
1
2
3
4
主线程中断线程


– 3. 总结分析 : 线程直接中断了, 线程中 run() 方法的最后一行代码也没有执行, 循环逻辑结束也没有执行, 说明线程很暴力的直接退出, 没有任何处理;




(2) stop 方法停止线程 捕获 ThreadDeath 异常




关于异常捕捉 : 

– 1. 捕捉 ThreadDeath 异常 : 线程捕获异常处理后, 还会继续执行 try catch 代码块下面的代码;

– 2. 不捕捉 ThreadDeath 异常 : 线程直接从 stop 时刻退出, 不会执行下面的代码;


stop() 停止线程 并 捕获异常 效果演示 : 

– 1. 代码示例 : 代码中比上面多了一个 catch ThreadDeath 异常的代码块, 其它一样;

[java] view plain copy
print ?
  1. public class StopDemo {  
  2.     public static class MyThread extends Thread{  
  3.         @Override  
  4.         public void run() {  
  5.             try {  
  6.                 System.out.println(”线程逻辑开始”);  
  7.                 super.run();  
  8.                 for(int i = 0; i < 5000; i ++){  
  9.                     System.out.println(i);  
  10.                     sleep(100);   
  11.                 }  
  12.                 System.out.println(”线程逻辑结束”);  
  13.             } catch (InterruptedException e) {  
  14.                 System.out.println(”捕获到了 InterruptedException 异常 , 进入了 catch 代码块”);  
  15.                 e.printStackTrace();  
  16.             }catch (ThreadDeath e){  
  17.                 System.out.println(”捕获到了 ThreadDeath 异常 , 进入了 catch 代码块”);  
  18.                 e.printStackTrace();  
  19.             }//catch代码块  
  20.             System.out.println(”run 方法结束”);  
  21.         }//run方法  
  22.     }//线程  
  23.       
  24.     public static void main(String[] args) throws InterruptedException {  
  25.         MyThread thread = new MyThread();   //新建线程  
  26.         thread.start();                     //线程启动  
  27.         Thread.sleep(500);                  //沉睡 500ms, 让线程打印 5 个数字  
  28.         thread.stop();                      //中断线程  
  29.         System.out.println(”主线程中断线程”);  
  30.     }  
  31. }  
public class StopDemo {
    public static class MyThread extends Thread{
        @Override
        public void run() {
            try {
                System.out.println("线程逻辑开始");
                super.run();
                for(int i = 0; i < 5000; i ++){
                    System.out.println(i);
                    sleep(100); 
                }
                System.out.println("线程逻辑结束");
            } catch (InterruptedException e) {
                System.out.println("捕获到了 InterruptedException 异常 , 进入了 catch 代码块");
                e.printStackTrace();
            }catch (ThreadDeath e){
                System.out.println("捕获到了 ThreadDeath 异常 , 进入了 catch 代码块");
                e.printStackTrace();
            }//catch代码块
            System.out.println("run 方法结束");
        }//run方法
    }//线程

    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();   //新建线程
        thread.start();                     //线程启动
        Thread.sleep(500);                  //沉睡 500ms, 让线程打印 5 个数字
        thread.stop();                      //中断线程
        System.out.println("主线程中断线程");
    }
}


– 2. 运行结果 : 

[java] view plain copy
print ?
  1. 线程逻辑开始  
  2. 0  
  3. 1  
  4. 2  
  5. 3  
  6. 4  
  7. 主线程中断线程  
  8. 捕获到了 ThreadDeath 异常 , 进入了 catch 代码块  
  9. run 方法结束  
  10. java.lang.ThreadDeath  
  11.     at java.lang.Thread.stop(Unknown Source)  
  12.     at com.hanshuliang.thread.StopDemo.main(StopDemo.java:31)  
线程逻辑开始
0
1
2
3
4
主线程中断线程
捕获到了 ThreadDeath 异常 , 进入了 catch 代码块
run 方法结束
java.lang.ThreadDeath
    at java.lang.Thread.stop(Unknown Source)
    at com.hanshuliang.thread.StopDemo.main(StopDemo.java:31)


– 3. 总结分析 : 如果捕获了 ThreadDeath 异常, 就会处理这个异常, 并会执行异常处理后面的代码, run() 方法的最后一行代码也执行完毕了;




5. return 停止线程



return 停止线程说明 : 

– 1. 执行过程 : 线程运行中, 随时监测中断标记, 如果检测到中断标记后, 直接 return 退出 run 方法;

– 2. 不建议使用该方法, 多个 return 会污染代码;


return 退出演示 : 

– 1. 代码示例 : 

[java] view plain copy
print ?
  1. public class ReturnDemo {  
  2.     public static class MyThread extends Thread{  
  3.         @Override  
  4.         public void run() {  
  5.             super.run();  
  6.             for(int i = 0; i < 500; i ++){  
  7.                 if(interrupted()){              //判断线程的中断状态, 如果中断直接 break  
  8.                     System.out.println(”停止状态, return 退出”);  
  9.                     return;  
  10.                 }  
  11.                 System.out.println(i);  
  12.             }  
  13.             System.out.println(”MyThread 线程执行完毕”);//线程结束标志  
  14.         }  
  15.     }  
  16.     public static void main(String[] args) throws InterruptedException {  
  17.         MyThread thread = new MyThread();       //创建线程并执行  
  18.         thread.start();                         //启动线程  
  19.         Thread.sleep(1);                        //沉睡 1 毫秒  
  20.         thread.interrupt();                     //中断线程  
  21.         System.out.println(”主线程执行完毕”);  //判断主线程停止  
  22.     }  
  23. }  
public class ReturnDemo {
    public static class MyThread extends Thread{
        @Override
        public void run() {
            super.run();
            for(int i = 0; i < 500; i ++){
                if(interrupted()){              //判断线程的中断状态, 如果中断直接 break
                    System.out.println("停止状态, return 退出");
                    return;
                }
                System.out.println(i);
            }
            System.out.println("MyThread 线程执行完毕");//线程结束标志
        }
    }
    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();       //创建线程并执行
        thread.start();                         //启动线程
        Thread.sleep(1);                        //沉睡 1 毫秒
        thread.interrupt();                     //中断线程
        System.out.println("主线程执行完毕");  //判断主线程停止
    }
}


– 2. 执行结果 : 

[java] view plain copy
print ?
  1. … …  
  2. 35  
  3. 36  
  4. 37  
  5. 38  
  6. 39  
  7. 主线程执行完毕  
  8. 停止状态, return 退出  
... ...
35
36
37
38
39
主线程执行完毕
停止状态, return 退出


– 3. 总结分析 : 使用 return 直接退出 run 方法, 确实实现了立即停止线程的目的, 但是我们还是建议使用 异常法 控制线程停止;



.



转载注明出处 : http://blog.youkuaiyun.com/shulianghan/article/details/52369486

Python多重继承中的钻石继承
NoerrorCode的博客
09-25 182
在Python中，多重继承是一种强大的特性，允许一个类从多个父类中继承属性和方法。然而，当多个父类存在同一个共同的父类时，就会出现钻石继承（diamond inheritance）问题，也称为菱形继承。这种情况下，子类继承了两个相同的父类，可能会导致方法冲突和意想不到的行为。MRO算法定义了多重继承中方法搜索的顺序，确保方法按照预期的顺序被调用。在钻石继承结构中，搜索顺序是从子类开始向上搜索父类，再返回到子类的另一个父类，最后到达最顶层的父类。通过了解方法解析顺序，我们可以明确地选择要调用的父类方法。
python 钻石继承_Python类继承及super()函数
weixin_42138545的博客
03-01 344
文章目录Python中单类继承普通类方法继承初始化函数继承Python中多类继承Python中单类继承Python是一门面向对象的编程语言，支持类继承。新的类称为子类(Subclass)，被继承的类称为父类、基类或者超类。子类继承父类后，就拥有父类的所有特性。类继承的简单例子：普通类方法继承class Fruit():def color(self):print("colorful")class A...
python棱形继承（钻石继承）
weixin_33709609的博客
01-04 366
class A(object): def func(self): print('A') class B(A): def func(self): super().func() print('B') class C(A): def func(self): super().func() print('C') class D(...
深入了解 Python 中的 MRO（方法解析顺序）
最新发布
XMYX-0
02-28 976
在 Python 中，MRO（方法解析顺序）是多重继承的核心机制。它决定了当一个类继承多个父类时，Python 如何解析并决定调用父类的方法。通过 MRO，Python 确保了在多重继承情况下方法不会发生冲突，且每个父类的方法都能按照预定的顺序正确调用。Python 使用一种称为C3 线性化的算法来计算 MRO，这一算法确保了在多继承中父类方法调用的顺序是明确且无歧义的。对于开发者而言，理解 MRO 有助于写出更清晰、易于维护的面向对象代码。
python钻石继承
杨佳佳的博客
05-20 4735
如果子类继承自两个单独的超类，而那两个超类又继承自同一个公共基类，那么就构成了钻石继承体系。这种继承体系很像竖立的菱形，也称作菱形继承。class Base: def __init__(self, value): self.value = value class One(Base): def __init__(self, value): Base...
python----钻石继承
writ的博客
06-29 616
当调用d.method()时，会按照方法解析顺序（Method Resolution Order, MRO）依次调用D、B、C和A的method方法。因此，在使用钻石继承时，需要注意继承关系和方法调用的顺序，以避免产生意外的结果。钻石继承是指在Python中，存在一种继承关系，其中一个子类继承自两个不同的父类，而这两个父类又共同继承自同一个父类。在这个示例中，类A是顶级父类，类B和类C都继承自A。最后，类D继承自B和C，形成了钻石继承的结构。
Python super()函数使用及多重继承
09-16
### Python `super()` 函数与多重继承详解 #### 一、`super()` 函数简介 在面向对象编程中，继承是一种常见的设计模式，它允许一个类（子类）继承另一个类（父类）的属性和方法。在 Python 中，`super()` 函数是一...
python继承及super()函数
hinewcc的博客
08-19 866
python继承及super() 函数介绍
解决python super()调用多重继承函数的问题
09-19
### 解决Python `super()` 调用多重继承函数的问题 在Python中，`super()` 函数被广泛用于实现多重继承。它可以帮助我们避免代码重复，并使得类的继承结构更加清晰。然而，在处理复杂的多重继承关系时，如何正确地...
Python多继承以及MRO顺序的使用
09-18
当我们通过`super()`函数调用方法时，Python会按照MRO顺序查找并执行方法。 以下是一些关于Python多继承和MRO顺序的关键点： 1. **单独调用父类的方法**： 在多继承中，可以通过直接指定父类名称和方法名来调用...
python 的钻石继承问题
Jibert的博客
04-18 570
如果子类继承自两个单独的超类，而那两个超类又继承自同一个公共基类，那么就构成了钻石继承体系。这种继承体系很像竖立的菱形，也称作菱形继承。 class Base: def __init__(self, value): print("This is Base __init__") self.value = value class One(Base): ...
super()函数
weixin_38170829的博客
08-30 429
1.简单的使用 在类的继承中，如果重定义某个方法，该方法会覆盖父类的同名方法，但有时，我们希望能同时实现父类的功能，这时，我们就需要调用父类的方法了，可通过使用super来实现，比如： 在上面，Animal 是父类，Dog 是子类，我们在 Dog 类重定义了greet方法，为了能同时实现父类的功能，我们又调用了父类的方法，看下面的使用： super的一个最常见用法...
python 钻石继承_python3--object类，继承与派生，super方法，钻石继承问题
weixin_28875235的博客
03-01 320
python3--object类，继承与派生，super方法，钻石继承问题发布时间：2018-04-13 20:38:05编辑：Run阅读(1914)昨天内容复习组合：什么有什么的关系(例:老师有生日)classBirthday:def__init__(self,year,month,day):self.year=yearself.month=monthself.day=da...
super函数
qq_42413204的博客
06-08 1015
super(type, obj) #返回绑定超类的实例(要求obj必须为type类型的实例)super() #返回绑定的超类的实例，等同于(class,实例方法的第一个参数),此方法需要用在方法内部。作用:返回绑定超类的实例，用超类的实例来调用其自身方法class A(object): def hello(self): print("A类的hello(self)") c...
python 多继承与super使用详解_Python高级编程之继承问题详解(super与mro)
weixin_39855869的博客
02-03 289
本文实例讲述了Python高级编程之继承问题。分享给大家供大家参考，具体如下：多继承问题1.单独调用父类：一个子类同时继承自多个父类，又称菱形继承、钻石继承。使用父类名.init(self)方式调用父类时：例：class Parent(object):def __init__(self, name):self.name = nameprint('parent的init结束被调用')class So...
Python面向对象中super用法与MRO机制
chb4715的博客
12-03 233
1. 引言 　　最近在研究django rest_framework的源码，老是遇到super，搞得一团蒙，多番查看各路大神博客，总算明白了一点，今天做一点总结。 2. 为什么要用super 1)让代码维护更加简单 　　Python是一门面向对象的语言，定义类时经常用到继承的概念，既然用到继承就少不得要在子类中引用父类的属性，我们可以通过“父类名.属性名”的方式来调用，代码如下： cl...
super() 函数
qq_43636375的博客
04-10 561
描述 super() 函数是用于调用父类(超类)的一个方法。 super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。 MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。 语法 以下是 super() 方法的语法: super(type[, object-or-type]...
python 钻石继承_【Python求助】关于带参数的钻石继承问题
weixin_31209173的博客
02-03 189
[Python] 纯文本查看 复制代码class A:def __init__(self, a, *args, **kwargs):print('进入A')self.a = aprint("A message:", self.a)print('离开A')class B(A):def __init__(self, b, *args, **kwargs):print('进入B')super(B, se...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值