详解LockSupport原理、使用场景及面试题

关注

原创 2022-07-25 09:13:02 1.5k 阅读 AI 写同款· GEO 优化 ›

【Java进阶营】Java技术专题-从底层分析LockSupport原理机制从底层分析LockSupport原理机制知识点 LockSupport的介绍 LockSupport类是Java6(JSR166-JUC)引入的一个类，提供了基本的线程同步原语。LockSupport实际上是调用了Unsafe类里的函数，归结到Unsafe里，只有两个函数，而仅仅两个简单的接口，就为上层提供了强大的同步原语，先来解析下两个函数是做什么的。 public native void unpark(Thread jthread); public native void park(boo. 阅读详情

1、LockSupport是什么

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
LockSupport中的park()和 unpark()的作用分别是阻塞线程和解除阻塞线程。
3种让线程等待和唤醒的方式：

方式1：使用Object中的wait()方法让线程等待，使用object中的notify()方法唤醒线程
方式2：使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程
方式3：LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程（可以理解为方式1和方式2的加强版）

2、waitNotify和awaitSignal的限制

synchronized -> wait->notify实现线程之间的等待唤醒

import java.util.concurrent.locks.LockSupport;

//   synchronized -> wait->notify
//   lock -> await -> signal
public class LockSupportTest {
    private static Object objectLock = new Object();

    public static void main(String[] args) {

       new Thread(()->{
           synchronized (objectLock){
               System.out.println(Thread.currentThread().getName() + "\t" + "coming in ....");

               try {
                   objectLock.wait();
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
               System.out.println(Thread.currentThread().getName() + "\t" + "被唤醒了 ....");
           }
       },"thA").start();

       new Thread(()->{
           synchronized (objectLock){
               System.out.println(Thread.currentThread().getName() + "\t" + "唤醒其他线程 ....");
               objectLock.notify();
           }

       },"thB").start();

    }
}

输出结果：

thA	coming in ....
thB	唤醒其他线程 ....
thA	被唤醒了 ....

如果让thA暂停三秒钟，让thB先获取锁objectLock，notify方法用来唤醒其他线程(实则没有任何线程等待)，再让thA获取锁，wait方法让thA线程等待，而thA不被唤醒，会一直处于等待/阻塞状态，即"thA 被唤醒了 …”一直不会输出。

调用顺序要先wait，在notify才能正常地实现线程之间的通知和唤醒。

还需要注意的是：
wait和notify方法必须要在同步块或者方法里面且成对出现使用，否则会抛出java.lang.IllegalMonitorStateException。
实现线程的等待和唤醒，Condition接口中的await和signal方法，同前面使用Object类中的wait和notify方法来实现，其效果大致相同。
都必须要先等待（wait/await），再唤醒（notify/signal）；等待和唤醒方法必须要在同步块或者方法里面且成对出现使用，否则会抛出java.lang.IllegalMonitorStateException

    private static Condition condition = lock.newCondition();
    private static Object objectLock = new Object();
    public static void main(String[] args) {

        new Thread(() -> {
            // 当前线程睡眠三秒钟,让thB先执行
            // try {
           //      TimeUnit.SECONDS.sleep(3);
           //  } catch (InterruptedException e) {
           //     throw new RuntimeException(e);
           //  }
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t" + "coming in ....");
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName() + "\t" + "被唤醒了 ....");
            } catch (RuntimeException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        }, "thA").start();

        new Thread(() -> {
            lock.lock();
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName() + "\t" + "唤醒其他线程 ....");
            } finally {
                lock.unlock();
            }

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

使用LockSupport可以解决如上两个问题，也会使代码更为简练。

3、LockSupport原理分析

LockSupport是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法。
LockSupport分别使用park、unpark实现等待和唤醒，见官网原话：

Basic thread blocking primitives for creating locks and other synchronization classes.
This class associates, with each thread that uses it, a permit (in the sense of the Semaphore class). A call to park will return immediately if the permit is available, consuming it in the process; otherwise it may block. A call to unpark makes the permit available, if it was not already available. (Unlike with Semaphores though, permits do not accumulate. There is at most one.) link

其解读如下：

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
LockSupport类使用了Permit（许可证）的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可（permit），permit只有两个值1和零，默认是零。
许可看成是一种(0和1)信号量（Semaphore），但与Semaphore不同的是，许可的累加上限是1
通过park()和unpark(thread)方法来实现阻塞和唤醒线程的操作，此外，park()+park(Object blocker) 可以用来阻塞当前线程阻塞传入的具体线程

LockSupport 源码摘要如下：

public class LockSupport {
   //  ...
    public static void park() {
        UNSAFE.park(false, 0L);
    }
    //  ...

    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(false, 0L);
        setBlocker(t, null);
    }
    public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
    }
 }

park和unpark方法都需要调用Unsafe类中native修饰的方法，底层交由C语言去实现
permit默认是0，调用park()方法，当前线程th1就会阻塞，直到别的线程th2调用unpark(Thread thread)，将当前线程th1的permit设置为1时（表示当前线程获取到许可），th1会被th2唤醒，然后会将permit再次设置为0并返回。
调用unpark(thread)方法后，就会将th1线程的许可permit设置成1（注意多次调用unpark方法，不会累加，pemit值还是1），使得th1线程被唤醒。

4、LockSupport使用案例

 public static void main(String[] args) {
        Thread threadA = new Thread(() -> {
            // 当前线程睡眠三秒钟,让thB先执行
            //try {
            //     TimeUnit.SECONDS.sleep(3);
            //} catch (InterruptedException e) {
            //     throw new RuntimeException(e);
            //}
            System.out.println(Thread.currentThread().getName() + "\t" + "coming in ....");
            LockSupport.park();
                /* 如果这里有两个LockSupport.park(),由于permit的值为1,
                上一行已经使用了permit,所以下一行被注释的打开会导致程序处于一直等待       的状态 * */
            //LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "\t" + "被唤醒了 ....");
        }, "thA");

        threadA.start();

        Thread threadB = new Thread(() -> {
            //try {
            //    TimeUnit.SECONDS.sleep(1);
            //} catch (InterruptedException e) {
            //    throw new RuntimeException(e);
            //}
               //如果有两个LockSupport.unpark(t1),由于permit的值最大为1,所以只能给park一个通行证
            //  LockSupport.unpark(threadA);
            LockSupport.unpark(threadA);
            System.out.println(Thread.currentThread().getName() + "\t" + "唤醒其他线程 ....");
        }, "thB");
        threadB.start();
   }

运行如上程序，即使不加锁，也不会出现异常 IllegalMonitorStateException，也不需要关心线程之间等待和唤醒的先后顺序。

5、总结

没有使用LockSupport的等待唤醒通知机制必须synchronized里面执行wait和notify，在lock里面执行await和signal，这上面这两个都必须要持有锁才能干
LockSupport：俗称锁中断，LockSupport 解决了 synchronized 和 lock 的痛点
LockSupport不用持有锁块，不用加锁，程序性能好，无须注意唤醒和阻塞的先后顺序，不容易导致卡死

形象理解LockSupport：