JUC并发编程（3）—锁中断机制

juc,并发,编程,中断,机制 · 浏览次数 : 10

小编点评

**1.什么是中断** 中断是一种在程序运行过程中，当某个线程处于活跃状态时，其他线程请求该线程停止执行的任务时产生的信号。 **2.源码解读(中断的相关API)** * `interrupt()` 方法用于设置线程的中断状态。如果线程处于正常活动状态，调用 `interrupt()` 方法只会设置线程的中断标志位为 true，但不会停止线程。 * `isInterrupted()` 方法用于检查当前线程是否被中断。该方法返回 true 表示线程被中断， false 表示线程未被中断。 * `AtomicBoolean` 是一个线程安全的布尔变量，用于存储线程的中断状态。 `AtomicBoolean` 的 `get()` 和 `set()` 方法确保线程在操作完成后进行同步，避免数据 races。 **3. 几种方式实现中断** * 通过 `interrupt()` 方法设置中断标志位。 * 通过 `isInterrupted()` 方法检查当前线程是否被中断。 * 通过 `AtomicBoolean` 的 `get()` 和 `set()` 方法设置中断标志位。 * 通过其他方法设置中断标志位，如设置 `isStop` 变量或调用 `interrupt()` 方法。 **4. 中断的几种类型** * **正常中断:** 当其他线程调用 `interrupt()` 方法时。 * **阻塞中断:** 当其他线程阻塞在方法中时，调用 `interrupt()` 方法。 * **非阻塞中断:** 当其他线程调用 `interrupt()` 方法，但方法在执行过程中阻塞时。 **5. 总结** 中断是一种在程序运行过程中，当某个线程处于活跃状态时，其他线程请求该线程停止执行的任务时产生的信号。可以通过多种方式实现中断，但每个方法都有其独特的优势和劣势。

正文

1.什么是中断
2.源码解读(中断的相关API)
3.如何使用中断标识停止线程

学习视频：https://www.bilibili.com/video/BV1ar4y1x727

1.什么是中断

一个线程不应该由其他线程来强制中断或停止,而是应该由线程自己自行停止,所以,Thread.stop、Thread.suspend、Thread. resume都已经被废弃了
在Java中没有办法立即停止一条线程,然而停止线程却显得尤为重要,如取消一个耗时操作。因此,Java提供了一种用于停止线程的机制——中断
中断只是一种协作机制,Java没有给中断增加任何语法,中断的过程完全需要程序员自己实现
若要中断一个线程,你需要手动调用该线程的interrupt方法,该方法也仅仅是将线程对象的中断标识设为true
每个线程对象中都有一个标识,用于标识线程是否被中断;该标识位为true表示中断,为false表示未中断;通过调用线程对象的interru pt方法将线程的标识位设为true;可以在别的线程中调用,也可以在自己的线程中调用
（简而言之就是怎么让一个线程中断停止！）

2.源码解读(中断的相关API)

①. void interrupt( )实例方法
interrupt( )仅仅是设置线程的中断状态未true,不会停止线程
源码解读
(如果这个线程因为wait()、join()、sleep()方法在用的过程中被打断(interupt),会抛出Interrupte dException)
在这里插入图片描述

②. boolean isInterrupted( )实例方法
判断当前线程是否被中断(通过检查中断标识位) 实例方法
在这里插入图片描述

③. static boolean interrupted( )静态方法

判断线程是否被中断,并清楚当前中断状态,这个方法做了两件事
(返回当前线程的中断状态 | 将当前线程的中断状态设为false)

原理:假设有两个线程A、B,线程B调用了interrupt方法,这个时候我们连接调用两次isInterrupted方法,第一次会返回true,然后这个方法会将中断标识位设置位false,所以第二次调用将返回false

在这里插入图片描述

  System.out.println(Thread.currentThread().getName()+"---"+Thread.interrupted());
  System.out.println(Thread.currentThread().getName()+"---"+Thread.interrupted());
  System.out.println("111111");
  Thread.currentThread().interrupt();///----false---> true
  System.out.println("222222");
  System.out.println(Thread.currentThread().getName()+"---"+Thread.interrupted());
  System.out.println(Thread.currentThread().getName()+"---"+Thread.interrupted());
  /**
   main---false
   main---false
   111111
   222222
   main---true
   main---false
   * */

④. 比较静态方法interrupted和实例方法isInterrupted

静态方法interrupted将会清除中断状态(传入的参数ClearInterrupted位true)
实例方法isInterrupted则不会(传入的参数ClearInterrupted为false)

3.如何使用中断标识停止线程

在需要中断的线程中不断监听中断状态,一旦发生中断,就执行型对于的中断处理业务逻辑

三种中断标识停止线程的方式

通过一个volatile变量实现
通过AtomicBoolean
通过Thread类自带的中断API方法实现

public class InterruptDemo{
    static volatile boolean isStop = false;
    static AtomicBoolean atomicBoolean = new AtomicBoolean(false);

    public static void m3(){
    Thread t1 = new Thread(() -> {
        while (true) {
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("-----isInterrupted() = true,程序结束。");
                break;
            }
            System.out.println("------hello Interrupt");
        }
    }, "t1");
    t1.start();

    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

    new Thread(() -> {
        t1.interrupt();//修改t1线程的中断标志位为true
    },"t2").start();
}

    /**
     * 通过AtomicBoolean
     */
    public static void m2(){
        new Thread(() -> {
            while(true)
            {
                if(atomicBoolean.get())
                {
                    System.out.println("-----atomicBoolean.get() = true,程序结束。");
                    break;
                }
                System.out.println("------hello atomicBoolean");
            }
        },"t1").start();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            atomicBoolean.set(true);
        },"t2").start();
    }

    /**
     * 通过一个volatile变量实现
     */
    public static void m1(){
        new Thread(() -> {
            while(true)
            {
                if(isStop)
                {
                    System.out.println("-----isStop = true,程序结束。");
                    break;
                }
                System.out.println("------hello isStop");
            }
        },"t1").start();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            isStop = true;
        },"t2").start();
    }
}

当前线程的中断标识为true,是不是就立刻停止？

线程调用interrupt()时

如果线程处于正常活动状态,那么会将线程的中断标志设置位true,仅此而已。被设置中断标志的线程将继续正常运行,不受影响。所以,interrupt( )并不能真正的中断线程,需要被调用的线程自己进行配合才行
如果线程处于被阻塞状态(例如处于sleep、wait、join等状态),在别的线程中调用当前线程对象的interrupt方法,那么线程立即被阻塞状态,并抛出一个InterruptedException异常)

中断只是一种协同机制,修改中断标识位仅此而已,不是立即stop打断
sleep方法抛出InterruptedException后,中断标识也被清空置为false,我们在catch没有通过调用th.interrupt( )方法再次将中断标识位设置位true,这就是导致无限循环了

    public static void m5()
   {
       Thread t1 = new Thread(() -> {
           while (true) {
               if (Thread.currentThread().isInterrupted()) {
                   System.out.println("-----isInterrupted() = true,程序结束。");
                   break;
               }
               try {
                   Thread.sleep(500);
               } catch (InterruptedException e) {
                   //线程的中断标志位重新设置为false,无法停下,需要再次掉interrupt()设置true
                   Thread.currentThread().interrupt();//???????
                   e.printStackTrace();
               }
               System.out.println("------hello Interrupt");
           }
       }, "t1");
       t1.start();

       try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }

       new Thread(() -> {
           t1.interrupt();//修改t1线程的中断标志位为true
       },"t2").start();
   }

   /**
    *中断为true后,并不是立刻stop程序
    */
   public static void m4()
   {
       //中断为true后,并不是立刻stop程序
       Thread t1 = new Thread(() -> {
           for (int i = 1; i <= 300; i++) {
               System.out.println("------i: " + i);
           }
           System.out.println("t1.interrupt()调用之后02: "+Thread.currentThread().isInterrupted());
       }, "t1");
       t1.start();

       System.out.println("t1.interrupt()调用之前,t1线程的中断标识默认值: "+t1.isInterrupted());
       try { TimeUnit.MILLISECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
       //实例方法interrupt()仅仅是设置线程的中断状态位设置为true,不会停止线程
       t1.interrupt();
       //活动状态,t1线程还在执行中
       System.out.println("t1.interrupt()调用之后01: "+t1.isInterrupted());

       try { TimeUnit.MILLISECONDS.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); }
       //非活动状态,t1线程不在执行中,已经结束执行了。
       System.out.println("t1.interrupt()调用之后03: "+t1.isInterrupted());
   }