线程唤醒机制

一、wait和notify实现等待和唤醒

要在 synchronized 锁中使用，切先等待才能进行唤醒

        Object object = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (object) {
                try {
                    System.out.println("================进入线程=============");
                    object.wait();
                    System.out.println("================线程被唤醒=============");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"t1");
        t1.start();
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() ->{
            synchronized (object){
                object.notify();
                System.out.println("进行唤醒==============");
            }
        },"t2").start();

二、await和signal实现等待和唤醒

需要在lock下使用，配合condition 实现，先等待才能进行唤醒

        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        Thread t1 = new Thread(() -> {
            lock.lock();
            try{
                System.out.println("=============进入方法==============");
                condition.await();
                System.out.println("=================线程被唤醒=================");
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }, "t1");
        t1.start();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() ->{
            lock.lock();
            try{
                condition.signal();
                System.out.println("=============唤醒操作================");
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        },"t2").start();

三、park和unpark实现等待和唤醒

unpark进行许可证的发布：最多只能发布一张许可证（不会累积）。如果一个方法出现两次LockSupport.park();就会出现问题。

基于LockSupport实现，无顺序要求，可以先park也可以先unpark。底层基于UNSAFE类实现

        Thread t1 = new Thread(() -> {
            System.out.println("===============进入线程执行=====================");
            LockSupport.park();
            System.out.println("===============线程被唤醒=====================");
        }, "t1");
        t1.start();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() ->{
            LockSupport.unpark(t1);
            System.out.println("================进行唤醒==================");
        },"t2").start();