• 多线程中断


    package com.test;
    // Demo1.java的源码
    class MyThread1 extends Thread {
        
        public MyThread1(String name) {
            super(name);
        }
    
        @Override
        public void run() {
            try {  
                int i=0;
                while (!isInterrupted()) {
                    Thread.sleep(15000); // 休眠15000ms,阻塞状态被打断会抛出异常,并且中断标记会被清除为false。运行状态打断不会抛出异常,并且中断标记会被清除为true。
                    i++;
                    System.out.println(Thread.currentThread().getName()+" ("+this.getState()+") loop " + i);  
                }
            } catch (InterruptedException e) {  
                System.out.println(Thread.currentThread().getName() +" ("+this.getState()+") catch InterruptedException.");  
            }
        }
    }
    
    public class Demo1 {
    
        public static void main(String[] args) {  
            try {  
                Thread t1 = new MyThread1("t1");  // 新建“线程t1”
                System.out.println(t1.getName() +" ("+t1.getState()+") is new.");  
    
                t1.start();                      // 启动“线程t1”
                System.out.println(t1.getName() +" ("+t1.getState()+") is started.");  
    
                t1.interrupt();
                System.out.println(t1.getName() +" ("+t1.getState()+") is interrupted.");
    
                Thread.sleep(300);
                System.out.println(t1.getName() +" ("+t1.getState()+") is interrupted now.");
            } catch (InterruptedException e) {  
                e.printStackTrace();
            }
        } 
    }
    package com.test;
    // Demo2.java的源码
    class MyThread extends Thread {
        
        public MyThread(String name) {
            super(name);
        }
    
        @Override
        public void run() {
            int i=0;
            while (!isInterrupted()) { //程序进入了死循环!
                System.out.println(isInterrupted());//false
                try {
                    Thread.sleep(15000); // 休眠15000ms,阻塞状态被打断会抛出异常,并且中断标记会被清除为false。运行状态打断不会抛出异常,并且中断标记会被清除为true。
                } catch (InterruptedException ie) {  
                    System.out.println(Thread.currentThread().getName() +" ("+this.getState()+") catch InterruptedException.");  
                }
                i++;
                System.out.println(Thread.currentThread().getName()+" ("+this.getState()+") loop " + i);  
            }
        }
    }
    
    public class Demo2 {
    
        public static void main(String[] args) {  
            try {  
                Thread t1 = new MyThread("t1");  // 新建“线程t1”
                System.out.println(t1.getName() +" ("+t1.getState()+") is new.");  
    
                t1.start();                      // 启动“线程t1”
                System.out.println(t1.getName() +" ("+t1.getState()+") is started.");  
    
                t1.interrupt();
                System.out.println(t1.getName() +" ("+t1.getState()+") is interrupted.");
    
                // 主线程休眠300ms,然后查看t1的状态。
                Thread.sleep(300);
                System.out.println(t1.getName() +" ("+t1.getState()+") is interrupted now.");
            } catch (InterruptedException e) {  
                e.printStackTrace();
            }
        } 
    }
    package com.test;
    
    // Demo2.java的源码
    class MyThread extends Thread {
    
        public MyThread(String name) {
            super(name);
        }
    
        @Override
        public void run() {
            int i = 0;
            while (!isInterrupted()) { // 正在运行状态,打断不会抛异常,并且中断标记为true,
                i++;
                System.out.println(Thread.currentThread().getName() + " (" + this.getState() + ") loop " + i);
            }
        }
    }
    
    public class Demo2 {
    
        public static void main(String[] args) {
            try {
                Thread t1 = new MyThread("t1"); // 新建“线程t1”
                System.out.println(t1.getName() + " (" + t1.getState() + ") is new.");
    
                t1.start(); // 启动“线程t1”
                System.out.println(t1.getName() + " (" + t1.getState() + ") is started.");
    
                t1.interrupt();
                // 主线程休眠300ms,然后查看t1的状态。
                Thread.sleep(300);
                System.out.println(t1.getName() + " (" + t1.getState() + ") is interrupted now.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    综合线程处于“阻塞状态”和“运行状态”的终止方式,比较通用的终止线程的形式如下:

    @Override
    public void run() {
        try {
            // 1. isInterrupted()保证,只要中断标记为true就终止线程。
            while (!isInterrupted()) {
                // 执行任务...
            }
        } catch (InterruptedException ie) {  
            // 2. InterruptedException异常保证,当InterruptedException异常产生时,线程被终止。
        }
    }

    下面是通过“额外添加标记”的方式终止“状态状态”的线程的示例:

    // Demo3.java的源码
    class MyThread extends Thread {
    
        private volatile boolean flag= true;
        public void stopTask() {
            flag = false;
        }
        
        public MyThread(String name) {
            super(name);
        }
    
        @Override
        public void run() {
            synchronized(this) {
                try {
                    int i=0;
                    while (flag) {
                        Thread.sleep(100); // 休眠100ms
                        i++;
                        System.out.println(Thread.currentThread().getName()+" ("+this.getState()+") loop " + i);  
                    }
                } catch (InterruptedException ie) {  
                    System.out.println(Thread.currentThread().getName() +" ("+this.getState()+") catch InterruptedException.");  
                }
            }  
        }
    }
    
    public class Demo3 {
    
        public static void main(String[] args) {  
            try {  
                MyThread t1 = new MyThread("t1");  // 新建“线程t1”
                System.out.println(t1.getName() +" ("+t1.getState()+") is new.");  
    
                t1.start();                      // 启动“线程t1”
                System.out.println(t1.getName() +" ("+t1.getState()+") is started.");  
    
                // 主线程休眠300ms,然后主线程给t1发“中断”指令。
                Thread.sleep(300);
                t1.stopTask();
                System.out.println(t1.getName() +" ("+t1.getState()+") is interrupted.");
    
                // 主线程休眠300ms,然后查看t1的状态。
                Thread.sleep(300);
                System.out.println(t1.getName() +" ("+t1.getState()+") is interrupted now.");
            } catch (InterruptedException e) {  
                e.printStackTrace();
            }
        } 
    }

    interrupted() 和 isInterrupted()的区别

    最后谈谈 interrupted() 和 isInterrupted()。
    interrupted() 和 isInterrupted()都能够用于检测对象的“中断标记”。
    区别是,interrupted()除了返回中断标记之外,它还会清除中断标记(即将中断标记设为false);而isInterrupted()仅仅返回中断标记。

    解释:

    2.1 终止处于“运行状态”的线程

    通常,我们通过“标记”方式终止处于“运行状态”的线程。其中,包括“中断标记”和“额外添加标记”。
    (01) 通过“中断标记”终止线程。
    形式如下:

    @Override
    public void run() {
        while (!isInterrupted()) {
            // 执行任务...
        }
    }

    说明:isInterrupted()是判断线程的中断标记是不是为true。当线程处于运行状态,并且我们需要终止它时;可以调用线程的interrupt()方法,使用线程的中断标记为true,即isInterrupted()会返回true。此时,就会退出while循环。
    注意:interrupt()并不会终止处于“运行状态”的线程!它会将线程的中断标记设为true。

    (02) 通过“额外添加标记”。
    形式如下:

    复制代码
    private volatile boolean flag= true;
    protected void stopTask() {
        flag = false;
    }
    
    @Override
    public void run() {
        while (flag) {
            // 执行任务...
        }
    }
    复制代码

    说明:线程中有一个flag标记,它的默认值是true;并且我们提供stopTask()来设置flag标记。当我们需要终止该线程时,调用该线程的stopTask()方法就可以让线程退出while循环。
    注意:将flag定义为volatile类型,是为了保证flag的可见性。即其它线程通过stopTask()修改了flag之后,本线程能看到修改后的flag的值。

    2.2 终止处于“阻塞状态”的线程

    通常,我们通过“中断”方式终止处于“阻塞状态”的线程。
    当线程由于被调用了sleep(), wait(), join()等方法而进入阻塞状态;若此时调用线程的interrupt()将线程的中断标记设为true。由于处于阻塞状态,中断标记会被清除,同时产生一个InterruptedException异常。将InterruptedException放在适当的为止就能终止线程,形式如下:

    复制代码
    @Override
    public void run() {
        try {
            while (true) {
                // 执行任务...
            }
        } catch (InterruptedException ie) {  
            // 由于产生InterruptedException异常,退出while(true)循环,线程终止!
        }
    }
    复制代码

    说明:在while(true)中不断的执行任务,当线程处于阻塞状态时,调用线程的interrupt()产生InterruptedException中断。中断的捕获在while(true)之外,这样就退出了while(true)循环!
    注意:对InterruptedException的捕获务一般放在while(true)循环体的外面,这样,在产生异常时就退出了while(true)循环。否则,InterruptedException在while(true)循环体之内,就需要额外的添加退出处理。形式如下:

    复制代码
    @Override
    public void run() {
        while (true) {
            try {
                // 执行任务...
            } catch (InterruptedException ie) {  
                // InterruptedException在while(true)循环体内。
                // 当线程产生了InterruptedException异常时,while(true)仍能继续运行!需要手动退出
                break;
            }
        }
    }
    复制代码

    说明:上面的InterruptedException异常的捕获在whle(true)之内。当产生InterruptedException异常时,被catch处理之外,仍然在while(true)循环体内;要退出while(true)循环体,需要额外的执行退出while(true)的操作。

    Thread中的stop()和suspend()方法,由于固有的不安全性,已经建议不再使用!

    interrupt()的作用是中断本线程。
    本线程中断自己是被允许的;其它线程调用本线程的interrupt()方法时,会通过checkAccess()检查权限。这有可能抛出SecurityException异常。
    如果本线程是处于阻塞状态:调用线程的wait(), wait(long)或wait(long, int)会让它进入等待(阻塞)状态,或者调用线程的join(), join(long), join(long, int), sleep(long), sleep(long, int)也会让它进入阻塞状态。若线程在阻塞状态时,调用了它的interrupt()方法,那么它的“中断状态”会被清除并且会收到一个InterruptedException异常。例如,线程通过wait()进入阻塞状态,此时通过interrupt()中断该线程;调用interrupt()会立即将线程的中断标记设为“true”,但是由于线程处于阻塞状态,所以该“中断标记”会立即被清除为“false”,同时,会产生一个InterruptedException的异常。
    如果线程被阻塞在一个Selector选择器中,那么通过interrupt()中断它时;线程的中断标记会被设置为true,并且它会立即从选择操作中返回。
    如果不属于前面所说的情况,那么通过interrupt()中断线程时,它的中断标记会被设置为“true”。
    中断一个“已终止的线程”不会产生任何操作。
  • 相关阅读:
    求求你,快去学习吧!!
    研究生英语读写译----topic3
    SQL----where 和 on 的区别
    SQL----语句执行顺序
    SQL----Inner Join、 Outer Join、Cross Join理解
    将一般的数值转换为金额格式(分隔千分位和自动增加小数点)
    伪元素 before 和 after 各种妙用
    抽空笑一笑
    别笑抽咯
    JavaScript继承方式详解
  • 原文地址:https://www.cnblogs.com/yaowen/p/9314841.html
Copyright © 2020-2023  润新知