LockSupport与线程中断

已于 2023-09-17 00:26:56 修改
阅读量50 收藏
点赞数
文章标签： java
于 2023-09-16 14:23:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46439731/article/details/132917481
版权

1.什么是中断机制？

首先，一个线程是否应该中断或停止，不应该由其他线程决定，而应该由线程自身决定，所以Thread.stop(),Thread.suspend(),Thread.resume()都已经被废弃了。其次，在Java中没有办法立刻停止一个线程，但是有些情况，比如需要取消一些耗时耗资源的操作确显得非常有必要，于是Java提供了一种用于停止线程的协商机制-中断，也即中断标识协商机制。
中断 只是一种协商机制，Java并没有给中断增加任何语法，中断的过程完全需要程序员自己来实现。
如要中断一个线程，你需要手动调用该线程的interrupt()方法，而该方法也仅是将线程对象的中断标识设置为true，接下来，你需要写代码不断检测当前线程的标识位，如果为true，代表别的线程请求这条线程中断，此时需要做什么，需要你自己写代码实现。
每个线程对象中都有一个中断标识位，用于表示线程是否被中断。true表示已中断，false表示未中断。通过调用线程对象的interrupt()方法将线程的标识位设置为true。可以在别的线程中调用，也可以在自己线程中调用。

2.中断常见方法

2.1 public void interrupt()

	将线程中断状态设置为true，发起一个协商而不会立即停止线程。

2.2 public static boolean interrupted()

	返回当前线程的中断状态，然后清除当前线程的中断状态，即将中断状态重新设置为false。

2.3 public boolean isInterrupted()

	返回当前线程的中断状态。

3.大厂面试题中断机制考点

3.1 如何停止中断运行中的线程？

3.1.1 通过volatile变量实现

代码如下：

package multiThreads;

import java.util.concurrent.TimeUnit;

public class InterruptTest {
    static volatile boolean isStop = false;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (true) {
                if (isStop) {
                    System.out.println(Thread.currentThread().getName() + "结束-------");
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "还未结束-------");
            }
        }, "a").start();


        TimeUnit.MILLISECONDS.sleep(5L);

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

    }
}

结果如下：
在这里插入图片描述

3.1.2 通过AtoicBoolean实现

代码如下：

package multiThreads;

import com.sun.org.apache.bcel.internal.generic.FADD;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

public class InterruptTest {
    static volatile boolean isStop = false;

    static AtomicBoolean atomicBoolean = new AtomicBoolean(false);

    public static void main(String[] args) throws InterruptedException {
//        m1Volatile();
        m2AtomicBoolean();

    }

    private static void m2AtomicBoolean() throws InterruptedException {
        new Thread(() -> {
            while (true) {
                if (atomicBoolean.get()) {
                    System.out.println(Thread.currentThread().getName() + "结束-------");
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "还未结束-------");
            }
        }, "a").start();


        TimeUnit.MILLISECONDS.sleep(5L);

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

    private static void m1Volatile() throws InterruptedException {
        new Thread(() -> {
            while (true) {
                if (isStop) {
                    System.out.println(Thread.currentThread().getName() + "结束-------");
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "还未结束-------");
            }
        }, "a").start();


        TimeUnit.MILLISECONDS.sleep(5L);

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

结果如下：
在这里插入图片描述

3.1.3 通过Thread类自带的中断api实例方法实现

代码如下：

package multiThreads;

import java.util.concurrent.TimeUnit;

public class InterruptTest2 {
    public static void main(String[] args) throws InterruptedException {


        Thread thread = new Thread(() -> {
            while (true) {
                Thread currentThread = Thread.currentThread();
                if (currentThread.isInterrupted()) {
                    System.out.println(currentThread.getName() + "被中断，结束时间：" + System.currentTimeMillis());
                    break;
                }
                System.out.println(currentThread.getName() + "执行----------");
            }
        }, "a");

        thread.start();
        TimeUnit.MILLISECONDS.sleep(10L);
        thread.interrupt();
        System.out.println("main打断时间:" + System.currentTimeMillis());

    }
}

结果如下：
在这里插入图片描述

3.2 当前线程的中断标识位为true，是不是线程就立刻停止了？

具体来说，当一个线程调用interrupt()方法的时候：
1.如果线程处于正常活动状态，那么会将中断标识设置为true，仅此而已，被设置中断标识的线程会继续正常运行，不受影响。所以，interrupt()只是协商，并不能立刻直接中断某个线程，需要被调用的线程自己进行配合才行。
2.如果线程处于阻塞状态，例如sleep(),wait(),join()等，那么线程会立刻退出阻塞状态，并抛出InterruptedException，且会将线程中断标识设置为false。

代码示例:

package multiThreads;

import java.util.concurrent.TimeUnit;

public class InterruptTest3 {
    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(() -> {
            for (int i = 0; i < 300; i++) {
                System.out.println(i);
            }
            System.out.println(Thread.currentThread().getName() + "的中断状态是：" + Thread.currentThread().isInterrupted());
        }, "a");

        thread.start();

        TimeUnit.MILLISECONDS.sleep(1L);

        thread.interrupt();
        System.out.println(thread.getName() + "的中断状态是：" + thread.isInterrupted() + "----------");
    }
}

运行结果：
在这里插入图片描述
在这里插入图片描述
可以看到线程a调用interrupt(）后，中断状态是true，但是线程还是依旧执行for循环。

3.3 对于静态方法Thread.interrupted()的理解？

1.返回当前线程的中断状态
2.将当前线程的中断状态设置为false

4 LockSupport

LockSupport是java.util.concurrent.locks.LockSupport中的一个类，用于创建锁和其他同步类的基本线程阻塞原语。
常见方法：
1.public static void park() ：阻塞线程
2.public static void unpark(Thread thread) ：解除阻塞线程

4.1 三种实现线程等待和唤醒的方法

4.1.1 Object的wait()和notify()

代码如下：

package multiThreads;

import java.util.concurrent.TimeUnit;

public class WaitTest {
    public static void main(String[] args) throws InterruptedException {
        Object objectLock = new Object();
        new Thread(() -> {
            synchronized (objectLock) {
                System.out.println("come in--------");
                try {
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("被唤醒-----");
            }

        }, "a").start();

        TimeUnit.SECONDS.sleep(1L);
        new Thread(() -> {
            synchronized (objectLock) {
                objectLock.notify();
                try {
                    TimeUnit.SECONDS.sleep(2L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("发出通知");
            }
        }, "b").start();
    }
}

运行结果如下：
在这里插入图片描述
结果解析：线程A中wait()方法会导致线程A进入阻塞状态，同时释放锁。另一个线程B获取锁后，执行notify()方法，会唤醒在此监视器(Monitor，此处指objectLock的Monitor)上等待的某一个线程，此处就是线程A，线程A被唤醒后，并不会立刻获取到锁，需要等线程B执行完毕，且释放锁之后，线程A才能重新尝试获取锁，因为没有其他线程争抢，所以线程B执行完毕释放锁之后，线程A自然就能获取到锁，继续执行后续代码。

注意点：
1.当使用object.wait()的时候，当前线程必须是锁对象的Monitor的持有者，否则会抛出 IllegalMonitorStateException异常
代码如下：

package multiThreads;

import java.util.concurrent.TimeUnit;

public class WaitTest {
    public static void main(String[] args) throws InterruptedException {
        Object objectLock = new Object();
        new Thread(() -> {
            //synchronized (objectLock) {
                System.out.println("come in--------");
                try {
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("被唤醒-----");
           // }

        }, "a").start();

        TimeUnit.SECONDS.sleep(1L);
        new Thread(() -> {
           // synchronized (objectLock) {
                objectLock.notify();
                try {
                    TimeUnit.SECONDS.sleep(2L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("发出通知");
            //}
        }, "b").start();
    }
}

结果如下：
在这里插入图片描述
2.注意wait()需要在notify()的前面执行，否则wait()的线程无人唤醒，将会一直等待下去。
代码如下：

package multiThreads;

import java.util.concurrent.TimeUnit;

public class WaitTest {
    public static void main(String[] args) throws InterruptedException {
        Object objectLock = new Object();
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (objectLock) {

                System.out.println("come in--------");
                try {
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("被唤醒-----");
            }

        }, "a").start();

        new Thread(() -> {
            synchronized (objectLock) {
                objectLock.notify();

                System.out.println("发出通知");
            }
        }, "b").start();
    }
}

运行结果：
在这里插入图片描述

4.1.2 Condition的await()和signal()

代码如下：

package multiThreads;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class WaitTest {
    public static void main(String[] args) throws InterruptedException {
        //waitNotify();
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        new Thread(() -> {
            lock.lock();
            try {
                System.out.println("a come in--");
                condition.await();
                System.out.println("a resume----");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.lock();
            }
        }, "a").start();


        TimeUnit.SECONDS.sleep(1L);


        new Thread(() -> {
            lock.lock();
            try {
                System.out.println("b come in");
                condition.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }, "b").start();

    }

   
}

运行结果如下：
在这里插入图片描述
Condition的await()等价于Object的wait()，都是让当前线程释放锁，并进入阻塞状态。
Condition的signal()等价于Object的notify()，都是唤醒在当前锁上等待的阻塞线程。

注意点:Condition中的await()和signal()执行的时候都需要保证当前线程获取了锁，其次注意await()之后一定要有线程来signal()进行唤醒。

4.1.3 使用LockSupport的park()和unpark()来实现
LockSupport.park()方法：

在这里插入图片描述
如果没有许可证（permit）会默认阻塞线程，直到别的线程给当前线程发放许可证(permit)，当前线程才会被唤醒。

LockSupport.unpark()方法：

在这里插入图片描述
给予入参Thread许可证(permit)，之前阻塞的LockSupport.park()方法会立刻返回。

示例代码如下：

package multiThreads;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class LockSupportTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("a come in");
            LockSupport.park();
            System.out.println("a is invoked");
        }, "a");
        thread.start();

        TimeUnit.SECONDS.sleep(1L);

        new Thread(() -> {
            LockSupport.unpark(thread);
            System.out.println("b invoke a");
        }, "b").start();
    }
}

运行结果：
在这里插入图片描述
可以看到unpark()和park()方法无需获取锁即可执行。

但是如果先执行unpark()，然后执行park(）呢？会导致线程a无法被唤醒，一直等待吗？代码验证，如下：

package multiThreads;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class LockSupportTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("a come in");
            LockSupport.park();
            System.out.println("a is invoked");
        }, "a");
        thread.start();

        TimeUnit.SECONDS.sleep(1L);

        new Thread(() -> {
            LockSupport.unpark(thread);
            System.out.println("b invoke a");
        }, "b").start();
    }
}

运行结果：
在这里插入图片描述
可以看到，依旧可以成功唤醒。park()和unpark()没有执行先后顺序要求。这是为什么呢？请看如下代码：

package multiThreads;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class LockSupportTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("a come in,当前时间:" + System.currentTimeMillis());
            LockSupport.park();
            System.out.println("a is invoked,当前时间:" + System.currentTimeMillis());
        }, "a");
        thread.start();

        TimeUnit.SECONDS.sleep(1L);

        new Thread(() -> {
            LockSupport.unpark(thread);
            System.out.println("b invoke a,当前时间:" + System.currentTimeMillis());
        }, "b").start();
    }
}

运行结果：
在这里插入图片描述
可以看到，a come in语句和 a is invoked语句的执行时间完全一致，也就是说这两行代码之间的LockSupport.park();没有生效。这是因为，先执行了下面的unpark()方法，导致这个park()失效了。类似于高速公路，提前买好了通行证unpark，到闸机处直接放行了，没有park拦截了。注意，虽然park()和unpark()没有了顺序要求，但是还是得成双成对的使用，否则某个park没有unpark会导致线程一直阻塞哦。

还有一个注意点，就是unpark获取的许可证(permit)对于被唤醒线程来说，最多只会有一个，即使你unpark()多次，被唤醒线程也最多持有一个许可证（permit）。但是每次从park()中被唤醒，都需要消耗一个permit。所以如果线程A park()两次，同时线程B unpark()两次，那么线程A第一次的park()可以被唤醒，但是第二次的park()无法被唤醒，这点需要注意。示例代码如下：

package multiThreads;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class LockSupportTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("a come in,当前时间:" + System.currentTimeMillis());
            LockSupport.park();
            LockSupport.park();
            System.out.println("a is invoked,当前时间:" + System.currentTimeMillis());
        }, "a");
        thread.start();

        TimeUnit.SECONDS.sleep(1L);

        new Thread(() -> {
            LockSupport.unpark(thread);
            LockSupport.unpark(thread);
            System.out.println("b invoke a,当前时间:" + System.currentTimeMillis());
        }, "b").start();
    }
}

运行结果：
在这里插入图片描述

面试题：
1.为什么可以突破wait()和notify()的顺序限制？
因为unpark()会让被唤醒线程获取permit，而唤醒因park()被阻塞的线程需要消耗permit。提前执行unpark()让被唤醒线程获得了一个permit，那么当其在执行park()的时候，因为拥有permit可以直接唤醒。
2.为什么unpark()两次后再park()两次，还是会被阻塞？
因为unpark()获取的permit至多只能拥有一个，调用两次unpark()也只会让被唤醒线程获得一个permit，而每次唤醒因park()阻塞的线程，需要消耗一个permit，因此在第二次park()的时候会被阻塞。

打灰高手
关注
【JUC】Java并发编程从挖坑到入土全解（4-一文讲通LockSupport与线程中断-＞长图预警）
aqin1012的博客
10-10 450
首先，一个线程不应该由其他线程强制中断或停止，而是应该由线程自己自行停止，自己来决定自己的命运（所以，Thread的stop()、suspend()、resume()都已经废弃了）其次，在Java中没有办法立即停止一条线程，然而停止线程又显得那么重要（比如需要取消一个耗时/错误操作）。因此，Java提供了一种用于停止线程的协商机制——中断，也即中断标识协商机制。中断只是一种协作协商机制，Java没有给中断增加任何语法，中断的过程完成完全要求程序员自己实现。
线程中断 interrupt 和 LockSupport
烟雨星空的博客
03-01 903
本文章将要介绍的内容有以下几点，读者朋友也可先自行思考一下相关问题： 线程中断 interrupt 方法怎么理解，意思就是线程中断了吗？那当前线程还能继续执行吗？ 判断线程是否中断的方法有几个，它们之间有什么区别？ LockSupport的 park/unpark 和 wait/notify 有什么区别？ sleep 方法是怎么响应中断的？ park 方法又是怎么响应中断的？ 线程中断相关方法...
Thread.interrupt与LockSupport
ZERO
06-02 1061
转载自：http://agapple.iteye.com/blog/970055 http://www.tuicool.com/articles/MveUNzF 首先抛几个问题： Thread.interrupt()方法和InterruptedException异常的关系？是由interrupt触发产生了InterruptedException...
线程中断与LockSupport
King Gigi的博客
03-16 526
线程中断机制通俗易懂
4、LockSupport与线程中断
赞的心路历程
06-09 328
如何停止、中断一个运行中的线程？首先一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止。所以，Thread.stop, Thread.suspend, Thread.resume 都已经被废弃了。其次在Java中没有办法立即停止一条线程，然而停止线程却显得尤为重要，如取消一个耗时操作。因此，Java提供了一种用于停止线程的机制——中断。中断只是一种协作机制，Java没有给中断增加任何语法，中断的过程完全需要程序员自己实现。若要中断一个线程，你需要手动调用该线程的 interrupt 方法，
线程的中断(Lock与synchronized)
weixin_30823227的博客
09-30 193
　　Thread包含interrupt()方法，因此你可以终止被阻塞的任务，这个方法将设置线程的中断状态。如果一个线程已经被阻塞，或者试图执行一个阻塞操作。那么设置这个线程的中断状态将 抛出InterruptedException。当抛出改异常或者该任务调用Thread.interrupted()时，中断状态将被复位。 　　查看Thread的API，关于中断的方法有： 　　void...
lock ，tryLock lockInterruptibly 区别
浩子的博客
03-29 1970
ReentrantLock 锁有好几种，除了常用的lock ，tryLock ，其中有个lockInterruptibly 。 先把API粘贴上来 lock public void lock() 获取锁。 如果该锁没有被另一个线程保持，则获取该锁并立即返回，将锁的保持计数设置为 1。 如果当前线程已经保持该锁，则将保持计数加 1，并且该方法立即返回。 如果该锁被另一个线程保持，则出于线程调
四、LockSupport与线程中断
余笙的博客
08-22 354
interrupt底层调用Unsafe中的native代码线程首先要获得并持有锁，必须在synchronized或lock中。
java线程阻塞中断与LockSupport使用介绍
09-05
如果线程中断状态已经设置，`park()` 会立即返回，即使没有调用过`unpark()`。 **7. Thread.interrupt()处理是否有回调函数？** Java API中并没有提供线程中断的直接回调函数。但是，可以通过在`run()` 方法中检查...
详解Java多线程编程中LockSupport类的线程阻塞用法
09-02
在Java多线程编程中，LockSupport类是一个重要的工具，它提供了一种低级别的线程阻塞和唤醒机制。LockSupport并不像synchronized或java.util.concurrent.locks包中的Lock接口那样提供锁的完整功能，但它提供了两个...
LockSupport-线程阻塞原语
惜暮
08-07 1417
基本介绍 基本的线程阻塞原语，被用于创建锁和其他同步类上。长久以来对线程阻塞与唤醒经常我们会使用object的wait和notify,除了这种方式，JDK1.6之后并发包还提供了另外一种方式对线程进行挂起和恢复，它就是并发包子包locks提供的LockSupport。 使用实例与简介 public static void main(String[] args) throws Interr...
Java线程并发中的锁——Lock(下)
路漫漫，水迢迢
05-20 3825
接上篇文章独占式同步状态获取与释放通过调用同步器的acquire(int arg)方法可以获取同步状态，该方法对中断不敏感，也就是由于线程获取同步状态失败后进入同步队列中，后续对线程进行中断操作时，线程不会从同步队列中移出，代码示例：public final void acquire(int arg) { if (!tryAcquire(arg) && acquireQueued(a
java基础--同步、Lock类、死锁、如何中断线程
hehanHH的博客
06-05 1368
一.同步代码块(同步锁)synchronized(锁){    操作功效数据的代码}同步代码块规则:当线程进入代码块时,先看一下有没有锁.如果有锁,就进入执行代码,进入的同时获得这把锁执行完毕,出同步代码块,把锁放回去如果没有锁,在同步代码块前等待优点:数据安全坏处:效率会降低二.同步方法使用关键字synchronized关键词声明在方法上作用:同一时间,只有一个线程进入同步方法中执行代码.//接...
利用lock中断线程
coach
01-13 629
ReentrantLock 的lock机制有2种，忽略中断锁和响应中断锁，这给我们带来了很大的灵活性。比如：如果A、B2个线程去竞争锁，A线程得到了锁，B线程等待，但是A线程这个时候实在有太多事情要处理，就是一直不返回，B线程可能就会等不及了，想中断自己，不再等待这个锁了，转而处理其他事情。这个时候ReentrantLock 就提供了2种机制，第一，B线程中断自己（或者别的线程中断它），但是Ree...
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 262
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 583
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 563
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
spring-boot 整合 mybatis
m0_72168501的博客
09-29 455
spring boot 整合 mybatis
Java线程中断与LockSupport深度解析
"java线程阻塞中断与LockSupport使用介绍" 在Java多线程编程中，线程的阻塞和中断以及同步工具的正确使用至关重要。`Thread.interrupt()` 和 `LockSupport` 是两个关键的概念，它们分别代表了对线程中断机制的不同...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值