java多线程方法的总结

interrupt、isinterrupted、interrupted的区别

从概念上来区分

• interrupted() 是Thread类的静态方法，测试当前线程是否已经中断，线程的中断状态也是由该方法清除。
• isInterrupted() 测试线程Thread对象是否已经处于中断状态。但不具有清除功能
• interrupt() 中断线程的方法，并不能真正中断线程，只是设置了一个中断标志

源码实现

从源码中可以帮助理解他们之间的区别
三个中断的方法

//静态的中断方法，返回中断的状态。//如果线程被中断，而且中断状态尚不清楚，那么，这个方法返回 true。与 isInterrupted()不同，//它将自动重置中断状态为 false，第二次调用 Thread.interrupted()方法，总是返回 false，除非中断了线程。public static boolean interrupted() {        return currentThread().isInterrupted(true);    }

// 线程是否中断//线程一旦被中断，isInterrupted()方法便会返回 true，而一旦 sleep()方法抛出异常，它将清空中断标志，此时isInterrupted()方法将返回 false。 public boolean isInterrupted() {        return isInterrupted(false);    }

private native boolean isInterrupted(boolean ClearInterrupted);

//中断线程的方法，并不能真正中断线程，只是设置了一个中断标志public void interrupt() {        if (this != Thread.currentThread())            checkAccess();        synchronized (blockerLock) {            Interruptible b = blocker;            if (b != null) {                interrupt0();           // Just to set the interrupt flag                b.interrupt(this);                return;            }        }        interrupt0();    }

代码实现证明结论

interrupt只是设置中断标志，并没有真正中断程序的执行

• 测试目的: 这个方法测试，interrupt()只是设置中断状态，并没有中断程序。
  
  • 预期结果：执行中断方法之后，还能继续执行下面的方法。说明程序没有中断
  • 真实结果：
    main当前线程的状态–0：false
    main调用中断方法，仍然继续执行，当前线程的状态–1：true
    main调用中断方法，仍然继续执行，当前线程的状态–2：true

 public static void interruptTest(){        Thread thread = Thread.currentThread();        System.out.println(thread.getName() + "当前线程的状态--0："+thread.isInterrupted());        Thread.currentThread().interrupt();        System.out.println(thread.getName() + "调用中断方法，仍然继续执行，当前线程的状态--1："+thread.isInterrupted());        System.out.println(thread.getName() + "调用中断方法，仍然继续执行，当前线程的状态--2："+thread.isInterrupted());    }

isInterrupted()只是获取当前线程的是否中断的状态，并不改变其状态的结果

• 测试目的: 这个方法测试，isInterrupted()只是获取当前线程的是否中断的状态，并不改变其状态的结果。
  
  • 预期结果：
    main当前线程的状态–0：false
    main当前线程的状态–1：true
    main当前线程的状态–2：true
  • 实际结果：确实如此
    main当前线程的状态–0：false
    main当前线程的状态–1：true
    main当前线程的状态–2：true
    */

public static void isInterruptTest(){        Thread thread = Thread.currentThread();        System.out.println(thread.getName() + "当前线程的状态--0："+thread.isInterrupted());        Thread.currentThread().interrupt();        System.out.println(thread.getName() + "当前线程的状态--1："+thread.isInterrupted());        System.out.println(thread.getName() + "当前线程的状态--2："+thread.isInterrupted());    }

isInterrupted()只是获取当前线程的是否中断的状态，并且改变其状态的结果

• 测试目的: 这个方法测试，isInterrupted()只是获取当前线程的是否中断的状态，并且改变其状态的结果。
  
  • 预期结果：
    main当前线程的状态–0：false
    main当前线程的状态–1：true
    main当前线程的状态–2：false
  • 真实结果：确实如此
    main当前线程的状态–0：false
    main当前线程的状态–1：true
    main当前线程的状态–2：false

 public static void interruptedTest(){        Thread thread = Thread.currentThread();        System.out.println(thread.getName() + " 当前线程的状态--0："+Thread.interrupted());        Thread.currentThread().interrupt();        System.out.println(thread.getName() + " 当前线程的状态--1："+Thread.interrupted());        System.out.println(thread.getName() + " 当前线程的状态--2："+Thread.interrupted());    }

中断线程的几种方式

interrupt()+sleep()+return;

主线程中调用t.interrupt()方法，
子线程的run方法中的sleep()方法会抛出InterruptedException异常，
在catch中捕获异常，并return当前线程的执行。

public static void isInterruptedTest(){        InterruptThreadt interruptThreadt = new InterruptThread().new InterruptThreadt();        interruptThreadt.start();        //主线程睡2m，让子线程有执行的机会        System.out.println(interruptThreadt.getName() + " 当前线程的状态--0：" + interruptThreadt.isInterrupted());        //终止线程        interruptThreadt.interrupt();        System.out.println(interruptThreadt.getName() + " 当前线程的状态--1：" + interruptThreadt.isInterrupted());        System.out.println(interruptThreadt.getName() + " 当前线程的状态--2：" + interruptThreadt.isInterrupted());    }

 /**     * 中断线程的执行方法一     *      */    class InterruptThreadt extends Thread{        @Override        public void run() {            super.run();            for (int i=0; i < 100; i++){                System.out.println("i = " + i);            }            try {                Thread.sleep(2000);                System.out.println(Thread.currentThread().getName() + " thread not interrupted ");            } catch (InterruptedException e) {                System.out.println(Thread.currentThread().getName() + " thread was interrupted ");                e.printStackTrace();                //中断线程 interrupt()方法，线程还可以继续执行，所以需要在catch中使用return。                return;            }            System.out.println("线程中断了，还是执行了...");        }    }

interrupt()+isInterrupted()+return

主线程中设置interrupt()中断标志
在子线程的run方法中的isInterrupted()判断如果是true，就停止子线程执行(return)

public static void interruptedThreadMethod2(){        InterruptThreadtx interruptThreadtx = new InterruptThread().new InterruptThreadtx();        interruptThreadtx.start();        //主线程睡2m，让子线程有执行的机会        System.out.println(interruptThreadtx.getName() + " 当前线程的状态--0：" + interruptThreadtx.isInterrupted());        //终止线程        interruptThreadtx.interrupt();        System.out.println(interruptThreadtx.getName() + " 当前线程的状态--1：" + interruptThreadtx.isInterrupted());        System.out.println(interruptThreadtx.getName() + " 当前线程的状态--2：" + interruptThreadtx.isInterrupted());    }

class InterruptThreadtx extends Thread{        @Override        public void run() {            super.run();            for (int i=0; i < 100; i++){                System.out.println("i = " + i);            }            System.out.println(Thread.currentThread().getName() + " thread not interrupted ");            if (this.isInterrupted()){                System.out.println(Thread.currentThread().getName() + " thread was interrupted ");                return;            }            System.out.println("线程中断了，还是执行了...");        }    }

守护线程

• 比任何线程的优先级都低的一种线程
• 在创建线程调用start()之前使用setDaemon(true)进行设置
• 当用户线程不存在时，jvm可能会将守护线程回收
  验证守护线程的优先级，可以看到结果，如果主线程（当前唯一的用户线程）结束后，守护线程没有执行完毕，也随之销毁。

public class DaemonThread {    public static void main(String[] args) {        //如果主线程中断，就执行守护线程        Thread thread = new DaemonThreadTest();        thread.setDaemon(true);        thread.start();        System.out.println("thread.isDaemon() = " + thread.isDaemon());        System.out.println("main over");    }    //一个实例，来验证守护线程的说法    public static void daemonTest(){        Thread thread = new DaemonThreadTest();        thread.setDaemon(true);        thread.start();    }    static class DaemonThreadTest extends Thread{        @Override        public void run() {            //直接打印，出来结果            System.out.println(" daemon thread is running.... ");            try {                //让守护线程睡1m，等待主线程（唯一的用户线程）执行完毕。                Thread.sleep(1000);                FileOutputStream fileOutputStream = new FileOutputStream("/Users/vobile_lzl/HSS-0814.sql");                fileOutputStream.write("gfdsgsd".getBytes());            } catch (FileNotFoundException e) {                e.printStackTrace();            } catch (IOException e) {                e.printStackTrace();            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("daemon write over ");        }    }}

 daemon thread is running.... thread.isDaemon() = truemain over