java多线程学习——（4）java多线程中断机制

理解中断
中断可以理解为线程的一个标识位属性，它表示一个运行中的线程是否被其他线程进行了中断操作。中断好比其他线程对该线程打了个招呼，其他线程通过调用该线程的intercept()方法对其进行中断操作。(引自《java并发编程的艺术》)

java中断机制能做什么？
假设现在有一个阻塞方法可能因为等不到所等的事件而无法终止，如果我们想终止该阻塞方法该怎么办？
方法1：调用stop()方法。该方法强制中断正在执行的线程，很可能造成临界资源的不一致，已经被弃用。
方法2：调用intercept()方法。该方法的线程被中断，它将尝试停止它正在做的事情而提前返回，并通过抛出 InterruptedException 表明它提前返回。（比stop()方法友好很多……）

---

中断方法使用实例

public class Run {

    public static void main(String[] args) {
        try {
            MyThread thread = new MyThread();
            thread.start();
            Thread.sleep(20);//modify 2000 to 20
            thread.interrupt();//请求中断MyThread线程
        } catch (InterruptedException e) {
            System.out.println("捕获中断异常");
            e.printStackTrace();
        }
        System.out.println("main线程执行完成");
    }
}

//第一种
public class MyThread extends Thread {
    @Override
    public void run() {
        while(true) {
            if (this.interrupted()) {
                System.out.println("mythreada线程被中断");
                break;
            }
        }
        System.out.println("mythread执行完成");//尽管线程被中断,但并没有结束运行。这行代码还是会被执行
    }
}

//执行结果
main线程执行完成//1
mythreada线程被中断//2
mythread执行完成//3

//第二种，当执行interrupted()方法后，抛出InterruptedException异常
public class MyThread extends Thread{
    @Override
    public void run() {
        try {
            while (true) {
                if (this.interrupted()) {
                    System.out.println("myThread线程被中断");
                    throw new InterruptedException();
                }
            }
        } catch (InterruptedException e) {
            /**这样处理不好
             * System.out.println("catch interrupted exception");
             * e.printStackTrace();
             */
            Thread.currentThread().interrupt();//这样处理比较好
        }
    }
}

通过执行结果可以发现，被中断的线程在被调用interrupt()方法后，会等到方法体执行完成之后才会退出，并不会强制中断。

注意：许多声明抛出InterrupttedException的方法(如Thread.sleep(long mills))这些方法在抛出异常之前，java虚拟机会先将该线程的中断标识位清除，isInterrupted()会返回fasle。

public class Interrupted {
    public static void main(String[] args) throws InterruptedException {
        Thread sleepRunner = new Thread(new SleepRunner(),"sleepRunner");
        sleepRunner.setDaemon(true);
        Thread busyRunner = new Thread(new BusyRunner(),"busyRunner");
        busyRunner.setDaemon(true);
        sleepRunner.start();
        busyRunner.start();
        //休眠，让sleep和busy线程充分执行
        TimeUnit.SECONDS.sleep(5);
        sleepRunner.interrupt();
        busyRunner.interrupt();
        System.out.println("sleepThread interrupted is:"+sleepRunner.isInterrupted());
        System.out.println("runThread interrupted is:"+busyRunner.isInterrupted());
    }

    static class SleepRunner implements Runnable{
        @Override
        public void run() {
            while (true){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    static  class BusyRunner implements Runnable{
        @Override
        public void run() {
            while (true){
            }
        }
    }
}
//返回结果
sleepThread interrupted is:false
runThread interrupted is:true
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at package1.Interrupted$SleepRunner.run(Interrupted.java:29)
    at java.lang.Thread.run(Thread.java:745)

Lock锁响应中断实例

public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock(true);

        Thread t1 =     new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println("我是终端锁，在等待被中断");
                    lock.lockInterruptibly();//此处如果是lock.lock(),及时线程2来中断也不会做任何响应.
                    System.out.println("如果我出现，则代表，我不能相应中断");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("我被打断了");
                } finally {
                    lock.unlock();
                }

            }
        });
        t1.start();

        Thread t2 =     new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    System.out.println(new Date() + ":我要睡5秒");
                    TimeUnit.SECONDS.sleep(5);
                    System.out.println("开始打断线程1");
                    t1.interrupt();
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println("已经打断了线程1");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });
        t2.start();
    }
//执行结果
Sat Jun 16 21:17:52 CST 2018:我要睡5秒
我是终端锁，在等待被中断
开始打断线程1
java.lang.InterruptedException
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222)
    at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)
    at lambda.TestDefault$1.run(TestDefault.java:31)
    at java.lang.Thread.run(Thread.java:745)
Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
    at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
    at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)
    at lambda.TestDefault$1.run(TestDefault.java:37)
    at java.lang.Thread.run(Thread.java:745)
我被打断了
已经打断了线程1

线程2在线程1前获取锁，所以当线程2执行lock.lockInterruptibly()方法时会阻塞，当线程2调用t1.interrupt()时，t1对中断作出了响应。所以，Lock锁的其中一个特性：lockInterruptibly()可响应中断！

---

参考博客：https://www.ibm.com/developerworks/cn/java/j-jtp05236.html

以上