文章目录
- 一、LockSupport概述
- 1、LockSupport是什么
- 2、三种等待唤醒机制
- 3、其他线程等待唤醒方式（了解）
- 二、代码实例分析
- 1、使用wait()+notify()
- （1）代码实例
- （2）分析总结
- 2、使用await()+signal()
- （1）代码实例
- （2）分析总结
- 3、使用LockSupport
- （1）代码实例
- （2）源码分析
- （3）分析总结
一、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个，累加无效。