必备技能：JUC中的LockSupport工具类

　　java高并发系列-第14天：JUC中的LockSupport工具类，必备技能
　　这是java高并发系列第14篇文章。
　　本文主要内容：
　　讲解3种让线程等待和唤醒的方法，每种方法配合具体的示例
　　介绍LockSupport主要用法
　　对比3种方式，了解他们之间的区别
　　LockSupport位于java.util.concurrent（简称juc）包中，算是juc中一个基础类，juc中很多地方都会使用LockSupport，非常重要，希望大家一定要掌握。
　　关于线程等待/唤醒的方法，前面的文章中我们已经讲过2种了：
　　方式1：使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程
　　方式2：使用juc包中Condition的await()方法让线程等待，使用signal()方法唤醒线程
　　这2种方式，我们先来看一下示例。
　　使用Object类中的方法实现线程等待和唤醒
　　示例1：
　　package com.itsoku.chat10;
　　import java.util.concurrent.TimeUnit;
　　/**
　　微信公众号：路人甲Java，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
　　*/
　　public class Demo1{

static Object lock = new Object();

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        synchronized (lock) {
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
            try {
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
        }
    });
    t1.setName("t1");
    t1.start();
    //休眠5秒
    TimeUnit.SECONDS.sleep(5);
    synchronized (lock) {
        lock.notify();
    }
}

　　}
　　输出：
　　1563592938744,t1 start!
　　1563592943745,t1被唤醒!
　　t1线程中调用lock.wait()方法让t1线程等待，主线程中休眠5秒之后，调用lock.notify()方法唤醒了t1线程，输出的结果中，两行结果相差5秒左右，程序正常退出。
　　示例2
　　我们把上面代码中main方法内部改一下，删除了synchronized关键字，看看有什么效果：
　　package com.itsoku.chat10;
　　import java.util.concurrent.TimeUnit;
　　/**
　　微信公众号：路人甲Java，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
　　*/
　　public class Demo2{

static Object lock = new Object();

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
        try {
            lock.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
    });
    t1.setName("t1");
    t1.start();
    //休眠5秒
    TimeUnit.SECONDS.sleep(5);
    lock.notify();
}

　　运行结果：
　　Exception in thread"t1"java.lang.IllegalMonitorStateException
　　1563593178811,t1 start!
　　at java.lang.Object.wait(Native Method)
　　at java.lang.Object.wait(Object.java:502)
　　at com.itsoku.chat10.Demo2.lambda$main$0(Demo2.java:16)
　　at java.lang.Thread.run(Thread.java:745)
　　Exception in thread"main"java.lang.IllegalMonitorStateException
　　at java.lang.Object.notify(Native Method)
　　at com.itsoku.chat10.Demo2.main(Demo2.java:26)
　　上面代码中将synchronized去掉了，发现调用wait()方法和调用notify()方法都抛出了IllegalMonitorStateException异常，原因：Object类中的wait、notify、notifyAll用于线程等待和唤醒的方法，都必须在同步代码中运行（必须用到关键字synchronized）。
　　示例3
　　唤醒方法在等待方法之前执行，线程能够被唤醒么？代码如下：
　　package com.itsoku.chat10;
　　import java.util.concurrent.TimeUnit;
　　/**
　　微信公众号：路人甲Java，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
　　*/
　　public class Demo3{

static Object lock = new Object();

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (lock) {
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
            try {
                //休眠3秒
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
        }
    });
    t1.setName("t1");
    t1.start();
    //休眠1秒之后唤醒lock对象上等待的线程
    TimeUnit.SECONDS.sleep(1);
    synchronized (lock) {
        lock.notify();
    }
    System.out.println("lock.notify()执行完毕");
}

　　}
　　运行代码，输出结果：
　　lock.notify()执行完毕
　　1563593869797,t1 start!
　　输出了上面2行之后，程序一直无法结束，t1线程调用wait()方法之后无法被唤醒了，从输出中可见，notify()方法在wait()方法之前执行了，等待的线程无法被唤醒了。说明：唤醒方法在等待方法之前执行，线程无法被唤醒。
　　关于Object类中的用户线程等待和唤醒的方法，总结一下：
　　wait()/notify()/notifyAll()方法都必须放在同步代码（必须在synchronized内部执行）中执行，需要先获取锁
　　线程唤醒的方法（notify、notifyAll）需要在等待的方法（wait）之后执行，等待中的线程才可能会被唤醒，否则无法唤醒
　　使用Condition实现线程的等待和唤醒
　　Condition的使用，前面的文章讲过，对这块不熟悉的可以移步JUC中Condition的使用，关于Condition我们准备了3个示例。
　　示例1
　　package com.itsoku.chat10;
　　import java.util.concurrent.TimeUnit;
　　import java.util.concurrent.locks.Condition;
　　import java.util.concurrent.locks.ReentrantLock;
　　/**
　　微信公众号：路人甲Java，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
　　*/
　　public class Demo4{

static ReentrantLock lock = new ReentrantLock();
static Condition condition = lock.newCondition();

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        lock.lock();
        try {
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
        } finally {
            lock.unlock();
        }
    });
    t1.setName("t1");
    t1.start();
    //休眠5秒
    TimeUnit.SECONDS.sleep(5);
    lock.lock();
    try {
        condition.signal();
    } finally {
        lock.unlock();
    }

}

　　}
　　输出：
　　1563594349632,t1 start!
　　1563594354634,t1被唤醒!
　　t1线程启动之后调用condition.await()方法将线程处于等待中，主线程休眠5秒之后调用condition.signal()方法将t1线程唤醒成功，输出结果中2个时间戳相差5秒。
　　示例2
　　我们将上面代码中的lock.lock()、lock.unlock()去掉，看看会发生什么。代码：
　　package com.itsoku.chat10;
　　import java.util.concurrent.TimeUnit;
　　import java.util.concurrent.locks.Condition;
　　import java.util.concurrent.locks.ReentrantLock;
　　/**
　　微信公众号：路人甲Java，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
　　*/
　　public class Demo5{

static ReentrantLock lock = new ReentrantLock();
static Condition condition = lock.newCondition();

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
        try {
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
    });
    t1.setName("t1");
    t1.start();
    //休眠5秒
    TimeUnit.SECONDS.sleep(5);
    condition.signal();
}

　　有异常发生，condition.await();和condition.signal();都触发了IllegalMonitorStateException异常。原因：调用condition中线程等待和唤醒的方法的前提是必须要先获取lock的锁。
　　示例3
　　唤醒代码在等待之前执行，线程能够被唤醒么？代码如下：
　　package com.itsoku.chat10;
　　import java.util.concurrent.TimeUnit;
　　import java.util.concurrent.locks.Condition;
　　import java.util.concurrent.locks.ReentrantLock;
　　/**
　　微信公众号：路人甲Java，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
　　*/
　　public class Demo6{

static ReentrantLock lock = new ReentrantLock();
static Condition condition = lock.newCondition();

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.lock();
        try {
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
        } finally {
            lock.unlock();
        }
    });
    t1.setName("t1");
    t1.start();
    //休眠5秒
    TimeUnit.SECONDS.sleep(1);
    lock.lock();
    try {
        condition.signal();
    } finally {
        lock.unlock();
    }
    System.out.println(System.currentTimeMillis() + ",condition.signal();执行完毕");
}

　　}
　　运行结果:
　　1563594886532,condition.signal();执行完毕
　　1563594890532,t1 start!
　　输出上面2行之后，程序无法结束，代码结合输出可以看出signal()方法在await()方法之前执行的，最终t1线程无法被唤醒，导致程序无法结束。
　　关于Condition中方法使用总结：
　　使用Condtion中的线程等待和唤醒方法之前，需要先获取锁。否者会报IllegalMonitorStateException异常
　　signal()方法先于await()方法之前调用，线程无法被唤醒
　　Object和Condition的局限性
　　关于Object和Condtion中线程等待和唤醒的局限性，有以下几点：
　　2中方式中的让线程等待和唤醒的方法能够执行的先决条件是：线程需要先获取锁
　　唤醒方法需要在等待方法之后调用，线程才能够被唤醒
　　关于这2点，LockSupport都不需要，就能实现线程的等待和唤醒。下面我们来说一下LockSupport类。
　　LockSupport类介绍
　　LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程。主要是通过park()和unpark(thread)方法来实现阻塞和唤醒线程的操作的。
　　每个线程都有一个许可(permit)，permit只有两个值1和0，默认是0。
　　当调用unpark(thread)方法，就会将thread线程的许可permit设置成1(注意多次调用unpark方法，不会累加，permit值还是1)。
　　当调用park()方法，如果当前线程的permit是1，那么将permit设置为0，并立即返回。如果当前线程的permit是0，那么当前线程就会阻塞，直到别的线程将当前线程的permit设置为1时，park方法会被唤醒，然后会将permit再次设置为0，并返回。
　　注意：因为permit默认是0，所以一开始调用park()方法，线程必定会被阻塞。调用unpark(thread)方法后，会自动唤醒thread线程，即park方法立即返回。
　　LockSupport中常用的方法
　　阻塞线程
　　void park()：阻塞当前线程，如果调用unpark方法或者当前线程被中断，从能从park()方法中返回
　　void park(Object blocker)：功能同方法1，入参增加一个Object对象，用来记录导致线程阻塞的阻塞对象，方便进行问题排查
　　void parkNanos(long nanos)：阻塞当前线程，最长不超过nanos纳秒，增加了超时返回的特性
　　void parkNanos(Object blocker,long nanos)：功能同方法3，入参增加一个Object对象，用来记录导致线程阻塞的阻塞对象，方便进行问题排查
　　void parkUntil(long deadline)：阻塞当前线程，直到deadline，deadline是一个绝对时间，表示某个时间的毫秒格式
　　void parkUntil(Object blocker,long deadline)：功能同方法5，入参增加一个Object对象，用来记录导致线程阻塞的阻塞对象，方便进行问题排查；
　　唤醒线程
　　void unpark(Thread thread):唤醒处于阻塞状态的指定线程
　　示例1
　　主线程线程等待5秒之后，唤醒t1线程，代码如下：
　　package com.itsoku.chat10;
　　import java.util.concurrent.TimeUnit;
　　import java.util.concurrent.locks.Condition;
　　import java.util.concurrent.locks.LockSupport;
　　import java.util.concurrent.locks.ReentrantLock;
　　/**
　　微信公众号：路人甲Java，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！