interrupt(), isInterrupted(),interrupted()区别，以及怎么中断停止一个线程

区别：

1，interrupt(), isInterrupted()是Thread类里面的实例方法，interrupted()是Thread类里面的静态方法

2，interrupt()是给线程打上一个中断的标志，让中断标志的值为true，并不会直接终止线程；

isInterrupted()返回线程的中断标志

interrupted() 返回当前线程的中断标志，且会重置当前线程的中断标志（如果当前线程执行了interrupt()方法，interrupted() 方法返回为true，第二次再执行这个方法，就会返回为false。因为第一次执行时，已经把中断标志重置了）

代码实例：

public class TestInterrupt {
    public static void main(String[] args) throws InterruptedException {
        Thread myThread = new Thread(new Runnable() {
            @Override
            public void run() {
                int i=0;
                while (true){
                    System.out.println(i++);
                }
            }
        });
        myThread.start();
        Thread.sleep(100);
        myThread.interrupt(); // 执行后，myThread里面的值还会一直输出

        System.out.println("myThread线程的中断状态标志1：" + myThread.isInterrupted()); // 输出为true
        System.out.println("myThread线程的中断状态标志2：" + myThread.isInterrupted()); // 输出为true


        System.out.println("main 线程的中断标志1：" + Thread.interrupted()); // 这个方法是静态方法，只会返回当前线程的中断状态，并且会重置当前线程的中断状态
        Thread.currentThread().interrupt();
        System.out.println("main 线程的中断标志2：" + Thread.interrupted()); // 返回true
        System.out.println("main 线程的中断标志3：" + Thread.interrupted()); // 返回false，因为被上一行的代码执行后，线程的中断状态重置了
    }
}

输出：

0
1
... // 中间省略
14035
myThread线程的中断状态标志1：true
14036
... // 中间省略
14601
myThread线程的中断状态标志2：true
14602
main 线程的中断标志1：false
14603
... // 中间省略
15359
main 线程的中断标志2：true
15360
... // 中间省略
17407
main 线程的中断标志3：false
17408

怎么中断停止一个线程：

方法1：使用stop()方法，源码中，这个方法已经被 @Deprecated标注，也就是这个方法是过时的方法，不被推荐

public class TestThread {
    public static void main(String[] args) throws InterruptedException {
        Thread myThread = new Thread(new Runnable() {
            @Override
            public void run() {
                int i=0;
                while (true){
                    System.out.println(i++);
                }
            }
        });
        myThread.start();
        Thread.sleep(100);
        myThread.stop();
    }
}

方法2： 使用interrupt(), isInterrupted()相结合的方式

public class TestThread {
    public static void main(String[] args) throws InterruptedException {
        Thread myThread = new Thread(new Runnable() {
            @Override
            public void run() {
                int i=0;
                while (true){
                    if(Thread.currentThread().isInterrupted()){ // 使用isInterrupted()的标志来判断，如果标志位true，那么结束，直接返回
                        return;
                    }
                    System.out.println(i++);
                }
            }
        });
        myThread.start();
        Thread.sleep(100);
        myThread.interrupt(); // 执行后，此时myThread的线程中断标志被置为true
    }
}

或者

public class TestThread {
    public static void main(String[] args) throws InterruptedException {
        Thread myThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    int i=0;
                    while (true){
                        if(Thread.currentThread().isInterrupted()){ // 判断线程状态是否中断，如果中断，抛出异常，结束该线程的运行
                            throw new InterruptedException(); 
                        }
                        System.out.println(i++);
                    }
                }catch (InterruptedException e){
                    System.out.println("线程被中断了");
                    e.printStackTrace();
                }
            }
        });

        myThread.start();
        Thread.sleep(100);
        myThread.interrupt(); // 执行后，此时myThread的线程中断标志被置为true
    }
}

方法三：使用标志位

public class TestThread {

    private static volatile int stopFlag = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread myThread = new Thread(new Runnable() {
            @Override
            public void run() {
                int i=0;
                while (true){
                    if(stopFlag == 1){ // 判断标志位是否为1，如果是1，则退出返回
                        return;
                    }
                    System.out.println(i++);
                }
            }
        });

        myThread.start();
        Thread.sleep(100);
        stopFlag = 1; // 把线程标志位置为1，表示需要停止运行
    }
}