LockSupport：灵活的线程工具类

作者: 大程子的技术成长路 | 来源:发表于2021-11-03 09:49 被阅读0次

LockSupport：灵活的线程工具类
java初入多线程10
用线程顺序打印A1B2C3....Z26
LockSupport 介绍
并发编程05--Java中的锁(LockSupport工具和Co
LockSupport
JUC锁框架_ LockSupport原理分析
LockSupport线程阻塞工具类
源码解读——LockSupport类
LockSupport与AQS

LockSupport是一个编程工具类，主要是为了阻塞和唤醒线程用的。使用它我们可以实现很多功能，今天主要就是对这个工具类的讲解，希望对你有帮助：

LockSupport 简介

LockSupport 是什么

我们在开头提过，LockSupport 是一个线程工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，也可以在任意位置唤醒。

它的内其实可以分为两类主要方法：park（阻塞线程） 和 unpark（启动唤醒线程）

// 1.阻塞当前线程
public static void park(Object blocker);
// 2.暂停当前线程，有超时时间
public static void parkNanos(Object blocker, long nanos);
// 3.暂停当前线程，直到某个时间
public static void parkUntil(Object blocker, long deadline);
// 4.无限期暂停当前线程
public static void park();
// 5.暂停当前线程，有超时时间
public static void parkNanos(long nanos);
// 6.暂停当前线程，直到某个时间
public static void parkUntil(long deadline);
// 7.恢复当前线程
public static void unpark(Thread thread)

我们注意到上面1、2、3方法，参数中都有一个blocker，这个blocker是用来记录线程被阻塞时被谁阻塞的。用于线程监控和分析工具来定位原因。

LockSupport使用示例

先interrupt再park

/**
* LockSupport案例1
* @author wangcp
* @date 2021/11/02 10:21
**/
public class LockSupportTest1 {
    public static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println(getName() + "进入线程");
            LockSupport.park();
            System.out.println("t1线程运行结束");
            System.out.println("是否中断：" + Thread.currentThread().isInterrupted());
        }
    }
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        t1.start();
        System.out.println("t1已经启动，但是内部进行了park");
        t1.interrupt();
        System.out.println("main线程结束");
    }
}

运行结果如下：

image-20211102134013482

先unpark再park

public class LockSupportTest1 {
    public static class MyThread extends Thread{
        @Override
        public void run() {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getName() + "进入线程");
            LockSupport.park();
            System.out.println("t1线程运行结束");
        }
    }
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        t1.start();
        System.out.println("t1已经启动，但是内部进行了park");
        LockSupport.unpark(t1);
        System.out.println("main线程结束");
    }
}

我们只需要在park之前先休眠1秒钟，这样可以确保unpark先执行。

image-20211102134542523.png

LockSupport相关问题详解

看完以上关于LockSupport的介绍与使用，我们来思考以下相关问题：

线程中断 interrupt 方法怎么理解，意思就是线程中断了吗？那当前线程还能继续执行吗？
判断线程是否中断的方法有几个，它们之间有什么区别？
LockSupport 的 park/unpark 和 wait/notify 有什么区别？
sleep 方法是怎么响应中断的？
park 方法又是怎么响应中断的？

线程中断相关方法

线程中和中断相关的方法有三个，分别介绍如下：

1.interrupt

我们一般都说这个方法是用来中断线程的，那么这个中断应该怎么理解呢？就是说把当前正在执行的线程中断掉，不让它继续往下执行吗？

其实，不然。此处，说的中断仅仅是给线程设置一个中断的标识（设置为true），线程还是会继续往下执行的。而线程怎么停止，则需要由我们自己去处理。

2.isInterrupted

判断当前线程的中断状态，即判断线程的中断标识是true还是false。注意，这个方法不会对线程原本的中断状态产生任何影响。

3.interrupted

也是判断线程的中断状态的。但是，需要注意的是，这个方法和 isInterrupted 有很大的不同。我们看下它们的源码：

public boolean isInterrupted() {  
    return isInterrupted(false);  
}

public static boolean interrupted() {  
    return currentThread().isInterrupted(true);  
}
//调用同一个方法，只是传参不同
private native boolean isInterrupted(boolean ClearInterrupted);

首先 isInterrupted 方法是线程对象的方法，而 interrupted 是Thread类的静态方法。

其次，它们都调用了同一个本地方法 isInterrupted，不同的只是传参的值，这个参数代表的是，是否要把线程的中断状态清除（清除即不论之前的中断状态是什么值，最终都会设置为false）。

因此，interrupted 静态方法会把原本线程的中断状态清除，而 isInterrupted 则不会。所以，如果你调用两次 interrupted 方法，第二次就一定会返回false，除非中间又被中断了一次。

sleep响应中断

线程中常用的阻塞方法，如sleep，join和wait 都会响应中断，然后抛出一个中断异常 InterruptedException。但是，注意此时，线程的中断状态会被清除。所以，当我们捕获到中断异常之后，应该保留中断信息，以便让上层代码知道当前线程中断了。通常有两种方法可以做到。

一种是，捕获异常之后，再重新抛出异常，让上层代码知道。另一种是，在捕获异常时，通过 interrupt 方法把中断状态重新设置为true。

下面，就以sleep方法为例，捕获中断异常，然后重新设置中断状态：

/**
* Interrupt 测试类
* @author wangcp
* @date 2021/11/02 14:22
**/
public class InterruptTest1 {

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            private int count = 0;
            @Override
            public void run() {
               count = new Random().nextInt(1000);
               count = count * count;
                System.out.println("count:" + count);
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (Exception e) {
                    System.out.println(Thread.currentThread().getName() + "线程第一次中断标志：" + Thread.currentThread().isInterrupted());
                    // 重新把线程中断状态设置为true。
                    Thread.currentThread().interrupt();
                    System.out.println(Thread.currentThread().getName() + "线程第二次中断标志：" + Thread.currentThread().isInterrupted());
                }
            }
        });
        t.start();

        Thread.sleep(100);
        t.interrupt();
    }
}

结果如下：

image-20211102150349839

按我理解，sleep() 方法会不断的判断线程是否被中断过，若检测到中断标志则会抛出异常InterruptedException。

park 和 interrupt 中断

park方法可以阻塞当前线程，如果调用unpark方法或者中断当前线程，则会从park方法中返回。

park方法对中断方法的响应和 sleep 有一些不太一样。它不会抛出中断异常，而是从park方法直接返回，不影响线程的继续执行。我们看下代码：

/**
* LockSupport 测试2
* @author wangcp
* @date 2021/11/02 15:13
**/
public class LockSupportTest2 {

    static class ParkThread implements Runnable{
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "开始阻塞");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "第一次结束阻塞");
            LockSupport.park();
            System.out.println("第二次结束阻塞");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new ParkThread());
        t.start();
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName() + "开始唤醒阻塞线程");
        t.interrupt();
        System.out.println(Thread.currentThread().getName() + "结束唤醒");
    }
}

打印结果如下：

image-20211102154150138

当调用interrupt方法时，会把中断状态设置为true，然后park方法会去判断中断状态，如果为true，就直接返回，然后往下继续执行，并不会抛出异常。注意，这里并不会清除中断标志。只要线程有中断标志，park() 就不再阻塞线程，不论调用多少次park() ，都不会阻塞线程。

unpark

unpark会唤醒被park的指定线程。但是，这里要说明的是，unpark 并不是简单的直接去唤醒被park的线程。看下JDK的解释：

image.png

unpark只是给当前线程设置一个许可证。如果当前线程已经被阻塞了（即调用了park），则会转为不阻塞的状态。如若不然，下次调用park方法的时候也会保证不阻塞。这句话的意思，其实是指，park和unpark的调用顺序无所谓，只要unpark设置了这个许可证，park方法就可以在任意时刻消费许可证，从而不会阻塞方法。

还需要注意的是，许可证最多只有一个，也就是说，就算unpark方法调用多次，也不会增加许可证。

park/unpark 和 wait/notify 区别

我们现在知道了 LockSupport 是用来阻塞和唤醒线程的，而且之前我们都知道 wait/notify 也是用来阻塞和唤醒线程的，那么它们相比，LockSupport有什么优点呢？

我们先举个案例：

/**
* LockSupport案例1
* @author wangcp
* @date 2021/11/02 10:21
**/
public class LockSupportTest1 {
    public static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println(getName() + "进入线程");
            LockSupport.park();
            System.out.println("t1线程运行结束");
        }
    }
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        t1.start();
        System.out.println("t1已经启动，但是内部进行了park");
        LockSupport.unpark(t1);
        System.out.println("LockSupport 进行了 unpark");
    }
}

上面代码的意思，我们定义一个线程，但在内部进行了park，因此需要unpark才能唤醒继续执行。不过注意观察，我们是在MyThread中进行的park，在main线程中进行的unpark。

这样看来，好像和 wait/notify 没有什么区别，那它们之间的区别到底是什么呢？主要区别如下：

wait和notify方法必须和同步锁 synchronized一块儿使用。而park/unpark使用就比较灵活了，没有这个限制，可以在任何地方使用。
park/unpark 使用时没有先后顺序，都可以使线程不阻塞（前面代码已验证）。而wait必须在notify前先使用，如果先notify，再wait，则线程会一直等待。
notify只能随机释放一个线程，并不能指定某个特定线程，notifyAll是释放锁对象中的所有线程。而unpark方法可以唤醒指定的线程。
调用wait方法会使当前线程释放锁资源，但使用的前提是必须已经获得了锁。而park不会释放锁资源。（以下代码验证）

/**
* 测试线程锁
* @author wangcp
* @date 2021/11/02 15:48
**/
public class LockSyncTest1 {

    private static Object lock = new Object();
    // 保存调用park的线程，以便后续唤醒
    private static Thread parkedThread;


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

        Thread t1 = new Thread(()->{
            synchronized (lock){
                System.out.println("unpark前");
                LockSupport.unpark(parkedThread);
                System.out.println("unpark后");
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //和t1线程用同一把锁时，park不会释放锁资源，若换成this锁，则会释放锁
                synchronized (this){
                    System.out.println("park 前");
                    parkedThread = Thread.currentThread();
                    LockSupport.park();
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("park 后");
                }
            }
        });

        t2.start();
        TimeUnit.MILLISECONDS.sleep(100);
        t1.start();
    }
}

以上代码，会一直卡在t2线程，因为park不会释放锁，因此t1也无法执行。

如果把t2的锁换成this锁，即只要和t1不是同一把锁，则t1就会正常执行，然后把t2线程唤醒。打印结果如下：

image-20211102160241994

LockSupport：灵活的线程工具类
LockSupport是一个编程工具类，主要是为了阻塞和唤醒线程用的。使用它我们可以实现很多功能，今天主要就是对这...
java初入多线程10
线程阻塞工具类：LockSupport LockSupport 是一个非常实用的线程阻塞工具，可以在线程内任意...
用线程顺序打印A1B2C3....Z26
LockSupport LockSupport是一个线程工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，...
LockSupport 介绍
LockSupport 的功能 LockSupport 是JDK 中提供的一个工具类，用来挂起和唤醒线程，这个类是...
并发编程05--Java中的锁(LockSupport工具和Co
Java中的锁 LockSupport工具当需要阻塞或唤醒一个线程的时候，都会使用LockSupport工具类来...
LockSupport
LockSupport简介 LockSupport用来实现线程的挂起和唤醒，它是Java6引入的一个工具类，它简单...
JUC锁框架_ LockSupport原理分析
一. LockSupport类介绍 LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程。主要是通过p...
LockSupport线程阻塞工具类
LockSupport是一个非常方便使用的线程阻塞工具，它可以在线程内任意位置让线程阻塞。与Thread.susp...
源码解读——LockSupport类
LockSupport LockSupport是一个线程阻塞工具，它可以在线程内任意位置让线程阻塞。优点跟Th...
LockSupport与AQS
LockSupport LockSupport类是Java6(JSR166-JUC)引入的一个类，提供了基本的线程...