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() = true
main over