LockSupport是做什么的？深入理解Java的三种线程等待通知机制

本文主要是介绍LockSupport是做什么的？深入理解Java的三种线程等待通知机制，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一、LockSupport概述

1、LockSupport是什么

在java.util.concurrent.locks包下，有一个不经常被人关注的类：LockSupport。用于创建锁和其他同步类的基本线程阻塞元语。

总共有如下几个方法：

LockSupport类使用了一种名为Permit（许可）的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可（Permit），但是与Semaphore不同的是，许可的累加上限是1。

大概的意思就是：LockSupport中的park()和unpark()的作用分别是阻塞线程和解除阻塞线程。类似于wait和notify，类似于await和signal。

2、三种等待唤醒机制

Java中线程等待唤醒机制有很多：
使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程；
使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程；
LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程。

那么这三种方式有什么区别呢？

3、其他线程等待唤醒方式（了解）

在Java中，除了这三种方式可以实现线程的阻塞、唤醒之外，还可以使用Semaphore、CyclicBarrier、CountDownLatch等类进行实现，但是这几种场景不在本文讨论范围之内，感兴趣小伙伴可以自行关注。

java之Semaphore信号量做限流
java的CyclicBarrier使用
java的CountDownLatch使用

二、代码实例分析

1、使用wait()+notify()

（1）代码实例

以下例子我们可以看出，使用wait()+notify() 需要配合synchronized 关键字：

// 正确使用wait + notify
public static void main(String[] args)
{Object objectLock = new Object();new Thread(() -> {synchronized (objectLock){System.out.println(Thread.currentThread().getName()+"\t ----come in");try {objectLock.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"\t ----被唤醒");}},"t1").start();//暂停几秒钟线程try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }new Thread(() -> {synchronized (objectLock){objectLock.notify();System.out.println(Thread.currentThread().getName()+"\t ----发出通知");}},"t2").start();
}

如果不用synchronized 的话，直接抛出了IllegalMonitorStateException：

public static void main(String[] args)
{Object objectLock = new Object();new Thread(() -> {System.out.println(Thread.currentThread().getName()+"\t ----come in");try {objectLock.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"\t ----被唤醒");},"t1").start();//暂停几秒钟线程try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }new Thread(() -> {objectLock.notify();System.out.println(Thread.currentThread().getName()+"\t ----发出通知");},"t2").start();
}

我们再反过来看看，如果先nofity，再wait会怎么样：
从结果我们也可以看出，先发出nofity信号再wait，wait之前的nofity信号是没有用的，只有wait之后的nofity信号才可以解除wait。

public static void main(String[] args)
{Object objectLock = new Object();new Thread(() -> {try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }synchronized (objectLock){System.out.println(Thread.currentThread().getName()+"\t ----come in");try {objectLock.wait(); // 阻塞住} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"\t ----被唤醒");}},"t1").start();new Thread(() -> {synchronized (objectLock){objectLock.notify();System.out.println(Thread.currentThread().getName()+"\t ----发出通知");}},"t2").start();
}

（2）分析总结

通过wait和notify实例我们可以看出，要使用这两个方法，必须要配合synchronized同步代码块才能实现，否则会抛出异常；而且必须要先等待后再唤醒，先唤醒后等待的话，是不会生效的。

2、使用await()+signal()

（1）代码实例

同样的，使用await()+signal()也需要配合lock()和unlock()方法：

    private static void main(String[] args){Lock lock = new ReentrantLock();Condition condition = lock.newCondition();new Thread(() -> {lock.lock();try{System.out.println(Thread.currentThread().getName()+"\t ----come in");condition.await();System.out.println(Thread.currentThread().getName()+"\t ----被唤醒");} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();}},"t1").start();//暂停几秒钟线程try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }new Thread(() -> {lock.lock();try{condition.signal();System.out.println(Thread.currentThread().getName()+"\t ----发出通知");}finally {lock.unlock();}},"t2").start();}

如果不使用lock()和unlock()方法，同样也会抛出异常：

而我们调整代码，先signal()后await()，同样也会导致await()阻塞：

public static void main(String[] args)
{Lock lock = new ReentrantLock();Condition condition = lock.newCondition();new Thread(() -> {try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }lock.lock();try{System.out.println(Thread.currentThread().getName()+"\t ----come in");condition.await();System.out.println(Thread.currentThread().getName()+"\t ----被唤醒");} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();}},"t1").start();new Thread(() -> {lock.lock();try{condition.signal();System.out.println(Thread.currentThread().getName()+"\t ----发出通知");}finally {lock.unlock();}},"t2").start();
}

（2）分析总结

通过await和signal实例我们可以看出，要使用这两个方法，也必须要配合lock同步代码块才能实现，否则会抛出异常；而且必须要先等待后再唤醒，先唤醒后等待的话，是不会生效的。

3、使用LockSupport

（1）代码实例

通过下面的实例我们可以看出，使用LockSupport的park和unpark方法，也可以实现线程的阻塞。并且如果先调用unpark的话，会累计一个许可证（最多累计一个），下次调用park时可以直接使用该许可证。

public static void main(String[] args)
{Thread t1 = new Thread(() -> {try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }System.out.println(Thread.currentThread().getName() + "\t ----come in"+System.currentTimeMillis());LockSupport.park();System.out.println(Thread.currentThread().getName() + "\t ----被唤醒"+System.currentTimeMillis());}, "t1");t1.start();//暂停几秒钟线程//try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }new Thread(() -> {LockSupport.unpark(t1);// LockSupport.unpark(t1); 多次unpark并不会累计多个许可证，只会累计一个System.out.println(Thread.currentThread().getName()+"\t ----发出通知");},"t2").start();}

（2）源码分析

通过底层的UNSAFE类，实现的。
最终都是调用的native方法。

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

（3）分析总结

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。

LockSuppot是一个线程阻寨工县类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻寨之后也有对应的唤醒方法。

LockSupport调用的Unsafe中的native代码。

LockSupport 提供park()和unpark()方法实现阻塞线程和解除线程阻塞的过程。

LockSupport和每个使用它的线程都有一个许可(permit)关联。每个线程都有一个相关的permit,permit最多只有一个，重复调用unpark也不会积累凭证。

线程阻寒需要消耗凭证(permit)，这个凭证最多只有1个。
当调用park方法时，如果有凭证，则会直接消耗掉这个凭证然后正常退出； 如果无凭证，就必须阻塞等待凭证可用。

而unpark则相反，它会增加一个凭证，但凭证最多只能有1个，累加无效。

这篇关于LockSupport是做什么的？深入理解Java的三种线程等待通知机制的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---