JUC并发编程之中断机制

女爷i 2023-10-14 09:31 6阅读 0赞

**目录**

1. 中断机制

1.1 中断原理

1.2 中断方法

1.2.1 interrupt()方法

1.2.2 isInterrupted()方法

1.2.3 Thread.interrupted()方法

1.3 正确处理中断

1.4 停止中断运行中的线程

1.4.1 volatile

1.4.2 原子类

--------------------

## 1. 中断机制 ##

在并发编程中，一个线程的执行可能会被另一个线程打断，这种打断称为"中断"。中断是一种线程间的通信机制，它允许一个线程通知另一个线程，请求它停止当前的工作并进行一些其他的操作。JUC中的中断机制是通过`interrupt()`方法实现的。

### 1.1 中断原理 ###

中断是通过线程的中断标志位来实现的。每个Java线程都有一个与之关联的boolean类型的中断标志位。当一个线程调用`interrupt()`方法时，它会将目标线程的中断标志位设置为`true`，表示该线程已被中断。然后，被中断的线程可以通过检查自己的中断状态来发现中断请求。

### 1.2 中断方法 ###

#### 1.2.1 `interrupt()`方法 ####

`interrupt()`方法是`Thread`类的实例方法，用于中断当前线程或指定目标线程。它的声明如下：

public void interrupt()

调用`interrupt()`方法会设置目标线程的中断标志位为`true`。如果目标线程正在阻塞状态（例如调用了`sleep()`、`wait()`、`join()`等方法），它会立即抛出`InterruptedException`异常，从阻塞状态返回。在线程在阻塞状态被中断抛出`InterruptedException`异常后，我们应该恢复中断状态。这是因为异常抛出后，中断标志位会被清除，如果我们希望后续代码能正确检测到中断状态，需要手动再次设置中断标志位。

catch (InterruptedException e) {
        // 恢复中断状态
        Thread.currentThread().interrupt();
    }

#### 1.2.2 `isInterrupted()`方法 ####

`isInterrupted()`方法是`Thread`类的实例方法，用于查询当前线程的中断状态。它的声明如下：

public boolean isInterrupted()

调用`isInterrupted()`方法会返回当前线程的中断标志位。注意，调用该方法不会清除中断标志位。

#### 1.2.3 `Thread.interrupted()`方法 ####

`Thread.interrupted()`方法是`Thread`类的静态方法，用于查询当前线程的中断状态，并清除中断标志位。它的声明如下：

public static boolean interrupted()

调用`Thread.interrupted()`方法会返回当前线程的中断状态，并将当前线程的中断标志位重置为`false`。

### 1.3 正确处理中断 ###

在线程执行的关键位置，我们应该检查线程的中断状态，并根据情况做出相应的响应。例如，在循环中执行某个任务时，我们可以使用`isInterrupted()`方法检查中断状态，并在发现线程已被中断时，及时终止循环并退出线程。

public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            // 执行任务...
        }
    }

有时候我们会将中断标志位传递给其他方法或对象，在处理完中断逻辑后，我们应该清除中断状态，以免影响后续的中断判断。可以使用`Thread.interrupted()`方法来清除中断标志位。

Thread th = new Thread(() -> {
               while (!Thread.interrupted()){
                   System.out.println(Thread.currentThread().getName());
                   Thread.currentThread().interrupt();
               }
            }, "th");
            th.start();

### 1.4 停止中断运行中的线程 ###

#### 1.4.1 volatile ####

`volatile`是Java中的关键字，用于声明变量。它的主要作用是保证被`volatile`修饰的变量对于所有线程是可见的，即每次读取`volatile`变量都会直接从主内存中获取最新值，而不是使用线程本地的缓存值。在多线程环境下，当一个线程修改了被`volatile`修饰的变量的值，该值会立即更新到主内存中，并通知其他线程，其他线程读取该变量时会看到最新的值。这样保证了对该变量的修改对所有线程都是可见的。`volatile`还可以防止指令重排，保证被`volatile`修饰的变量的读写操作是有序的，不会出现意料之外的结果。

public class Test {
    
        private static volatile boolean key=false;
        public static void main(String[] args) throws InterruptedException {
                 new Thread(()->{
                     while (true){
                         if(key){
                             System.out.println(Thread.currentThread().getName()+ "终止");
                             break;
                         }
                         System.out.println(Thread.currentThread().getName()+" 执行");
                     }
                 }).start();
                 
                 new Thread(()->{
                     key=true;
                 }).start();
        }
    }

#### 1.4.2 原子类 ####

原子类是JUC提供的一组用于实现原子操作的工具类，它们在特定操作上保证了原子性。原子类通过CAS（Compare and Swap）算法实现原子操作，CAS是一种乐观锁技术，它能够在不使用锁的情况下实现线程安全的并发操作。

常用的原子类包括：`AtomicInteger`、`AtomicLong`、`AtomicBoolean`等。

public class Test {
    
        private static AtomicBoolean atomicBoolean=new AtomicBoolean(false);
        public static void main(String[] args) throws InterruptedException {
                 new Thread(()->{
                     while (true){
                         if(atomicBoolean.get()){
                             System.out.println(Thread.currentThread().getName()+ "终止");
                             break;
                         }
                         System.out.println(Thread.currentThread().getName()+" 执行");
                     }
                 }).start();
    
                 new Thread(()->{
                    atomicBoolean.set(true);
                 }).start();
        }
    }

第三种情况就是使用文章一开始介绍的中断方法。这里省略。