LockSupport线程唤醒机制（附代码示例）

线程等待和唤醒的三种方法：

方式1:使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程

方式2:使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程

方式3:LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程

方式1与方式2：线程先要获得并持有锁，必须在锁块(synchronized或lock)中； 必须要先等待后唤醒，线程才能够被唤醒

方式1:

Object类中的wait, notify, notifyAll用于线程等待和唤醒的方法，都必须在synchronized内部执行 (必须用到关键字synchronized)。

wait和notify方法必项要在同步块或者方法里面，且成对出现使用

先wait再notify才行

   @Test
    public void m1() throws InterruptedException {
        new Thread(() -> {
        
            synchronized (objectLock) { //去掉 synchronized 报java.lang.IllegalMonitorStateException，且使用wait()和notify()必须要 synchronized
                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();

        TimeUnit.SECONDS.sleep(1);

        new Thread(() -> {
            synchronized (objectLock) {
                objectLock.notify();
                System.out.println(Thread.currentThread().getName() + " 发出通知");
            }
        }, "t2").start();
    }

方式2:

Condition中的线程等待和唤醒方法之前，需要先获取锁;

一定要先await后signal, 不要反了

 @Test
    public void m2() {
        new Thread(() -> {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t" + "come in");
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t" + "被唤醒");
            } 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() + " 发出通知");
            } finally {
                lock.unlock();
            }
        }, "t2").start();
    }

方式3：

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。LockSupport中的park()和unpark()的作用分别是阻塞线程和解除阻塞线程。

LockSupport类使用了一种名为Permit (许可)的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可(permit),  permit只有两个值1和零，默认是零。可以把许可看成是一种(0,1)信号量 (Semaphore)，但与Semaphore不同的是，许可的累加上限是1。

permit默认是零，所以一开始调用park()方法，当前线程就会阻塞，直到别的线程将当前线程的permit设置为1时，park方法会被唤醒，然后会将permit再次设置为零并返回。

调用unpark(thread)方法后，就会将thread线程的许可permit设置成1(注意多次调用unpark方法，不会累加，permit值还是1)会自动唤醒thread线程，即之前阻塞中的LockSupport park()方法会立即返回。

优点：

1.无锁块要求

2.之前错误的先唤醒后等待，LockSupport照样支持

此外

LockSupport.park方法的线程等待之后，唤醒方式有2种:

1.调LockSupport.unpark方法

2.调用等待线程的interrupt()方法，main给等待的t1线程发送中断信号协商，可以唤醒t1线程

public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            //暂停两秒，后发等待，仍然可被唤醒
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t" + "come in");
            LockSupport.park();
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "\t" + "被唤醒");
        }, "t1");
        t1.start();

        //一个线程只能针对一个线程发一个通行证
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " 发出通知");
            LockSupport.unpark(t1);
        }, "t2").start();

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " 发出通知");
            LockSupport.unpark(t1);
        }, "t3").start();
    }