线程阻塞和线程中断

贼爱学习的小黄

于 2023-07-28 17:13:14 发布

阅读量564

点赞数

分类专栏：小黄重学JUC 文章标签： java 开发语言

本文链接：https://blog.csdn.net/Yellow_Star___/article/details/131984518

版权

小黄重学JUC 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本专栏学习内容又是来自尚硅谷周阳老师的视频

有兴趣的小伙伴可以点击视频地址观看

中断机制

简介

Java线程中断机制是一种用于协作式线程终止的机制。它通过将一个特殊的中断标志设置为线程的状态来实现。当线程被中断时，它可以检查这个中断标志并采取相应的措施来停止线程的执行。

首先

一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止，自己决定自己的命运

其次

在Java中没有办法立刻停止一条线程，中断也只是一种协商机制，Java并没有给中断增加任何语法，中断的过程需要程序员自己实现。

三大中断方法说明

方法名	作用
void interrupt()	中断这个线程
static boolean interrupted()	测试当前线程是否中断。该方法可以清除线程的中断状态。
boolean isInterrupted()	测试这个线程是否被中断，true代表中断

线程中断实现

小黄认为线程中断是一种编程的思想，例如A线程需要中断，应该是A线程去监听某一个数据，当这个数据改变时，中断该线程

while(true) {
    if (xxx) {
        //线程中断
        break;
    }
}

线程中断应该是由被中断线程自己操作的，例如在餐厅中，服务员来提醒小明此地禁止吸烟，然后由小明将烟掐灭，而不是服务员上去直接把烟掐灭

通过volatile关键字

volatile 是 Java 中的一个关键字，用于修饰变量。当一个变量被声明为 volatile 时，表明这个变量是被多个线程共享的，并且在多线程环境下具有特殊的可见性和禁止重排序的特性。

public class VolatileDemo {
    static volatile boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (true) {
                if (flag) {
                    System.out.println(Thread.currentThread().getName() + "掐灭烟头");
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "正在吸烟。。。");
            }
        },"t1").start();

        TimeUnit.MILLISECONDS.sleep(20);

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "  禁止吸烟!!");
            flag = true;
        },"t2").start();
    }
}

从执行结果可以看出，t2线程发出指令后，t1线程中断了，至于多输出了一次是因为上一次循环还没有执行结束

使用AtomicBoolean

AtomicBoolean 是 Java 中 java.util.concurrent.atomic 包提供的一个原子布尔类型，用于在多线程环境中进行原子性的布尔操作。

使用原理跟volatile差不多，都是通过其他线程改变监听对象属性来中断线程

public class AtomicDemo {
    static AtomicBoolean flag = new AtomicBoolean(false);

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (true) {
                if (flag.get()) {
                    System.out.println(Thread.currentThread().getName() + "掐灭烟头");
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "正在吸烟。。。");
            }
        },"t1").start();

        TimeUnit.MILLISECONDS.sleep(20);

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "  禁止吸烟!!");
            flag.set(true);
        },"t2").start();
    }
}

使用Thread API

需要isInterrupted()和interrupt()配合使用

public class InterruptDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println(Thread.currentThread().getName() + "掐灭烟头");
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "正在吸烟。。。");
            }
        }, "t1");
        t1.start();

        TimeUnit.MILLISECONDS.sleep(20);

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "  禁止吸烟!!");
            t1.interrupt();
        },"t2").start();
    }
}

源码分析

interrupt()

interrupt()调用了interrupt0()，而interrupt0()是本地方法，也就是由c++写的

特别需要注意的是interrupt0()旁边的注释Just to set the interrupt flag只是改变状态，并不是中断线程

isInterrupted()

isInterrupted()底层调用的也是一个本地方法，传了一个false进去

当参数为false时，isInterrupted(false)方法仅返回当前线程的中断状态，但不会清除中断状态。当参数为true时，isInterrupted(true)方法在返回中断状态之后会将中断状态重置为false，相当于清除了中断状态。

深度解析案例

先来看一下API文档，有两个特别需要注意的地方

如果线程正在阻塞状态，调用该线程的interrupt()会将中断状态清楚，并且收到异常
中断不存在的线程没有任何效果

案例

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 30; i++) {
            if (Thread.currentThread().isInterrupted()) {
                System.out.println(Thread.currentThread().getName() + "：中断");
                break;
            }
            try {
                TimeUnit.MILLISECONDS.sleep(200);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("===interrupt=== : " + i);
        }
    }, "t1");
    t1.start();
    TimeUnit.MILLISECONDS.sleep(2000);
    t1.interrupt();
}

可以从结果看出，在现场休眠时中断线程，会抛出异常，但是线程会继续运行，这是因为会清除中断状态

解决方案：在捕获异常时，再次中断线程

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 30; i++) {
            if (Thread.currentThread().isInterrupted()) {
                System.out.println(Thread.currentThread().getName() + "：中断");
                break;
            }
            try {
                TimeUnit.MILLISECONDS.sleep(200);
            } catch (InterruptedException e) {
                //重新中断线程
                Thread.currentThread().interrupt();
                e.printStackTrace();
            }
            System.out.println("===interrupt=== : " + i);
        }
    }, "t1");
    t1.start();
    TimeUnit.MILLISECONDS.sleep(2000);
    t1.interrupt();
}

静态方法interrupted()

interrupted()会将线程中断，并且清除线程的中断状态

public static void main(String[] args) {
    System.out.println(Thread.interrupted());//false
    System.out.println(Thread.interrupted());//false
    Thread.currentThread().interrupt();
    System.out.println(Thread.interrupted());//true
    System.out.println(Thread.interrupted());//false
}

可以看一下源码，跟isInterrupted()一样，调用的都是本地方法isInterrupted()，不过传参为true，方法在返回中断状态之后会将中断状态重置为false，相当于清除了中断状态。

LockSupport

简介

LockSupport 是 Java 并发包中的一个工具类，提供了线程阻塞和唤醒的能力，说到线程阻塞和唤醒就不得不提到两种已经学过的方式

synchronized配合wait()、notify()
Lock配合await()、signal()

wait()、notify()实现阻塞和唤醒

执行以下代码，可以实现阻塞和唤醒，这里需要了解的是wait()会暂时释放锁，直到被唤醒之后重新排队获取锁

public static void main(String[] args) throws InterruptedException {
    Object object = new Object();
    new Thread(() -> {
        synchronized (object) {
            try {
                System.out.println(Thread.currentThread().getName() + "----come in");
                object.wait();
                System.out.println(Thread.currentThread().getName() + "----被唤醒");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    },"t1").start();

    TimeUnit.MILLISECONDS.sleep(200);

    new Thread(() -> {
        synchronized (object) {
            object.notify();
            System.out.println(Thread.currentThread().getName() + "----发送通知");
        }
    },"t2").start();
}

//结果
t1----come in
t2----发送通知
t1----被唤醒

await()、signal()实现阻塞和唤醒

执行以下代码，可以实现阻塞和唤醒

public static void main(String[] args) throws InterruptedException {
    ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    new Thread(() -> {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "----come in");
            condition.await();
            System.out.println(Thread.currentThread().getName() + "----被唤醒");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            lock.unlock();
        }
    }, "t1").start();

    TimeUnit.MILLISECONDS.sleep(200);

    new Thread(() -> {
        lock.lock();
        try {
            condition.signal();
            System.out.println(Thread.currentThread().getName() + "----发送通知");
        }finally {
            lock.unlock();
        }
    }, "t2").start();
}

缺点

上述两种代码从功能上都可以实现线程的阻塞和唤醒，但是都有两个相同的缺点

必须要加锁

public static void main(String[] args) throws InterruptedException {
    Object object = new Object();
    new Thread(() -> {
        try {
            System.out.println(Thread.currentThread().getName() + "----come in");
            object.wait();
            System.out.println(Thread.currentThread().getName() + "----被唤醒");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }, "t1").start();

    TimeUnit.MILLISECONDS.sleep(200);

    new Thread(() -> {
        object.notify();
        System.out.println(Thread.currentThread().getName() + "----发送通知");
    }, "t2").start();
}

如果不加锁，程序会报错

必须先阻塞，在唤醒

public static void main(String[] args) throws InterruptedException {
    Object object = new Object();
    new Thread(() -> {
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        synchronized (object) {
            try {
                System.out.println(Thread.currentThread().getName() + "----come in");
                object.wait();
                System.out.println(Thread.currentThread().getName() + "----被唤醒");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    },"t1").start();

    new Thread(() -> {
        synchronized (object) {
            object.notify();
            System.out.println(Thread.currentThread().getName() + "----发送通知");
        }
    },"t2").start();
}

如果先唤醒，程序会一直阻塞

LockSupport使用

先介绍一下主要的API，有点类似于上高速公路，进入高速时领取一个通行证，出高速归还通行证

方法	作用
static void park()	禁止当前线程进行线程调度，除非许可证可用。
static void unpark(Thread thread)	为给定的线程提供许可证（如果尚未提供）。

代码

从使用上就可以看出它没有加锁释放锁的过程

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        System.out.println(Thread.currentThread().getName() + "----come in");
        LockSupport.park();
        System.out.println(Thread.currentThread().getName() + "----被唤醒");
    }, "t1");
    t1.start();

    TimeUnit.MILLISECONDS.sleep(200);

    new Thread(() -> {
        LockSupport.unpark(t1);
        System.out.println(Thread.currentThread().getName() + "----发送通知");
    }, "t2").start();
}

优势

它可以先颁发通行证，当线程执行到需要通行证时，会直接通过，不再等待

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName() + "----come in");
        LockSupport.park();
        System.out.println(Thread.currentThread().getName() + "----被唤醒");
    }, "t1");
    t1.start();

    new Thread(() -> {
        LockSupport.unpark(t1);
        System.out.println(Thread.currentThread().getName() + "----发送通知");
    }, "t2").start();
}

//结果
t2----发送通知
t1----come in
t1----被唤醒

重点说明

对于一个线程来说，最多只能拥有一个通行证

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName() + "----come in");
        LockSupport.park();
        LockSupport.park();
        System.out.println(Thread.currentThread().getName() + "----被唤醒");
    }, "t1");
    t1.start();

    new Thread(() -> {
        LockSupport.unpark(t1);
        LockSupport.unpark(t1);
        System.out.println(Thread.currentThread().getName() + "----发送通知");
    }, "t2").start();
}

执行上述代码，虽然调用了两次unpark()但是t1还是只拥有一个通行证，导致程序阻塞

贼爱学习的小黄

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
线程阻塞和线程中断

Java线程中断机制是一种用于协作式线程终止的机制。它通过将一个特殊的中断标志设置为线程的状态来实现。当线程被中断时，它可以检查这个中断标志并采取相应的措施来停止线程的执行。首先一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止，自己决定自己的命运其次在Java中没有办法立刻停止一条线程，中断也只是一种协商机制，Java并没有给中断增加任何语法，中断的过程需要程序员自己实现。是 Java 并发包中的一个工具类，提供了线程阻塞和唤醒的能力，说到线程阻塞和唤醒就不得不提到两种已经学过的方式。
复制链接

扫一扫