第四章LockSupport与线程中断

文章目录

线程中断机制
- 面试题
- 什么是中断机制?
- 实现三种中断方式
- - 通过一个volatile变量实现
  - 通过AtomicBoolean（原子布尔型）
  - 通过Thread类自带的中断api方法实现
- API源码分析
- - 当前线程的中断标识为true，是不是线程就立刻停止？
  - - 后手案例-深入
  - 静态方法Thread.interrupted()，谈谈你的理解
LockSupport是什么
线程等待唤醒机制
- Object的wait和notify
- - Wait方法
  - notify
- Condition接口中的await和signal
- - Object和Condition使用的限制条件
- LockSupport类中的park等待和unpark唤醒
- - 阻塞
  - 唤醒

线程中断机制

面试题

void	interrupt()	中断此线程
static boolean	interrupted()	测试当前线程是否已被中断
boolean	isInterrupted()	测试此线程是否已经被中断

三个方法了解过吗？用在哪？
如何停止一个运行中的线程？
如何中断一个运行中的线程？？

什么是中断机制?

首先

一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止。所以，Thread.stop, Thread.suspend, Thread.resume 都已经被废弃了。

其次

在Java中没有办法立即停止一条线程，然而停止线程却显得尤为重要，如取消一个耗时操作。
因此，Java提供了一种用于停止线程的协商机制——中断。
- 中断只是一种协作协商机制，Java没有给中断增加任何语法，中断的过程完全需要程序员自己实现。

**定义：**中断一个正在运行的线程，（run方法还没有执行结束），普通线程会在run方法执行结束后自动停止，我们的中断其实就是更改线程的状态，想让线程终止，只有run方法执行完毕，就自然终止了

如果我们想中断一个线程，你需要手动的调用该线程的interrupt方法，该方法也仅仅是将线程的中断标识设成true，这里并没有真正的让线程停止运行，接着你需要自己写代码不断地检测当前线程的标识位，如果为true，表示别的线程要求这条线程中断，此时究竟该做什么需要你自己写代码实现。

每个线程对象中都有一个标识，用于表示线程是否被中断；该标识位为true表示中断，为false表示未中断；
通过调用线程对象的interrupt方法将该线程的标识位设为true；可以在别的线程中调用，也可以在自己的线程中调用。
eg.顾客在无烟餐厅中吸烟，服务员希望他别吸烟了，不是强行停止他吸烟，而是给他的标志位打为true，具体的停止吸烟还是要顾客自己停止。（体现了协商机制）

实现三种中断方式

通过共享变量进行中断
通过AtomicBoolean(原子布尔型）
使用Thread.interrupt()静态方法进行中断

通过一个volatile变量实现

volatile保证了可见性，t2修改了标志位后能马上被t1看到

public class InterruptDemo {
    static volatile boolean isStop = false;

    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            while (true){
                if (isStop){
                    System.out.println(Thread.currentThread().getName()+"\t isStop被修改为true，程序终止");
                    break;
                }
                System.out.println("t1 ------hello volatile");//----------------------如果没停止，那就一直打印
            }
        },"t1").start();
        Thread.sleep(20);
        new Thread(()->{
            isStop = true;
        },"t2").start();
    }
}
t1 ------hello volatile
t1 ------hello volatile
t1 ------hello volatile
t1 ------hello volatile
t1	 isStop被修改为true，程序终止

通过AtomicBoolean（原子布尔型）

public class InterruptDemo {
    static volatile boolean isStop = false;
    static AtomicBoolean atomicBoolean = new AtomicBoolean(false);
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            while (true){
                if (atomicBoolean.get()){
                    System.out.println(Thread.currentThread().getName()+"\t atomicBoolean被修改为true，程序终止");
                    break;
                }
                System.out.println("t1 ------hello volatile");//----------------------如果没停止，那就一直打印
            }
        },"t1").start();
        Thread.sleep(20);
        new Thread(()->{
           atomicBoolean.set(true);
        },"t2").start();
    }
}
//t1 ------hello volatile
//t1 ------hello volatile
//t1 ------hello volatile
//t1 ------hello volatile
//t1 ------hello volatile
//t1 ------hello volatile
//t1   atomicBoolean被修改为true，程序终止

通过Thread类自带的中断api方法实现

public class InterruptDemo {
    static volatile boolean isStop = false;
    static AtomicBoolean atomicBoolean = new AtomicBoolean(false);
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println(Thread.currentThread().getName() + "\t isInterrupted()被修改为true，程序终止");
                    break;
                }
                System.out.println("t1 ------hello volatile");//----------------------如果没停止，那就一直打印
            }
        }, "t1");
        t1.start();
        Thread.sleep(20);
        new Thread(()->{
            t1.interrupt();
        },"t2").start();
    }
}

public void interrupt() 实例方法，实例方法interrupt()仅仅是设置线程的中断状态为true，发起一个协商而不会立刻停止线程
public static boolean interrupted() 静态方法，Thread.interrupted();判断线程是否被中断，并清除当前中断状态这个方法做了两件事：
- 1 返回当前线程的中断状态
- 2 将当前线程的中断状态设为false（这个方法有点不好理解，因为连续调用两次的结果可能不一样。）
public boolean isInterrupted() 实例方法，判断当前线程是否被中断（通过检查中断标志位）

API源码分析

实例方法interrupt()，没有返回值

//Thread.java
public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();

        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                interrupt0();           // Just to set the interrupt flag----调用了interrupt0（）方法
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
    }

//Thread.java
    /* Some private helper methods */
    private native void setPriority0(int newPriority);
    private native void stop0(Object o);
    private native void suspend0();
    private native void resume0();
    private native void interrupt0();  //---------------------------调用了c底层
    private native void setNativeName(String name);

实例方法isInterrupted，返回布尔值

//Thread.java
public boolean isInterrupted() {
    return isInterrupted(false);
}

//Thread.java
private native boolean isInterrupted(boolean ClearInterrupted);//也调用了c底层

具体来说，当对一个线程，调用 interrupt() 时：

如果线程处于正常活动状态，那么会将该线程的中断标志设置为 true，仅此而已。被设置中断标志的线程将继续正常运行，不受影响。所以， interrupt() 并不能真正的中断线程，需要被调用的线程自己进行配合才行。
当线程调用sleep/wait/join等方法处于阻塞状态的时候，收到thread.interrupt(),就会抛出一个中断异常，InterruptedException，当抛出这个异常的时候（无论是使用那种判断方式），当前线程的中断状态会被清除（也就是Thread类中那个特别设置的中断属性）
（中断不活动的线程不会产生任何影响，看下面案例）

当前线程的中断标识为true，是不是线程就立刻停止？

否
- 仅仅设置了一个中断状态，并没有真正的停止线程
看看中断是否会立即停止这个300的线程
- 否，虽然中断标志位变了。但是i一直在循环

public class InterruptDemo1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 300; i++) {
                System.out.println("---------" + i);
            }
            System.out.println("after t1.interrupt()---第2次----"+Thread.currentThread().isInterrupted());
        }, "t1");
        t1.start();
        System.out.println("before t1.interrupt()----"+t1.isInterrupted());
        t1.interrupt();
        Thread.sleep(3);
        System.out.println("after t1.interrupt()---第1次---"+t1.isInterrupted());
        Thread.sleep(3000);
        t1.interrupt();
        System.out.println("after t1.interrupt()---第3次---"+t1.isInterrupted());
    }
}
//before t1.interrupt()----false
//---------0
//---------1
//---------2
//---------3
//....
//---------136
//after t1.interrupt()---第1次---true    ------此处中断标志位设置为了true,但是t1仍然在运行
//---------137
//---------298
//---------299
//after t1.interrupt()---第2次----true
//after t1.interrupt()---第3次---false//中断不活动的线程不会产生任何影响，线程结束后应该是自动变为了false

before t1.interrupt()----false
- 一个线程的默认中断标识位为false
after t1.interrupt()—第1次—true
- 我们线程的中断标识位为true，但是线程并没有结束，还在打印
after t1.interrupt()—第2次----true
- 再次证明，虽然中断标识位变成了true，但是线程并没有结束
after t1.interrupt()—第3次—false
- 这次输出，t1线程已经结束了，虽然我们再次进行调用interrupt()，但是我们的中断标识位还是false
- 说明中断不活动的线程不会产生任何影响

后手案例-深入

在我们基本中断程序的骨架上 + 一个sleep阻塞
中断异常且会导致程序无限循环.

public class InterruptDem02 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
                while (true){
                    if (Thread.currentThread().isInterrupted()){
                        System.out.println(Thread.currentThread().getName()+"\t"+
                                "中断标志位："+Thread.currentThread().isInterrupted()+"程序终止");
                        break;
                    }
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                         // Thread.currentThread().interrupt();  假如加了这个，程序可以终止，只会爆异常
                        e.printStackTrace();
                    }
                    System.out.println("-----hello InterruptDemo03");
                }
        }, "t1");
        t1.start();
        TimeUnit.MILLISECONDS.sleep(1);
        new Thread(()-> t1.interrupt(),"t2").start();
    }
}
/*java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at com.lsc.day04.InterruptDem02.lambda$main$0(InterruptDem02.java:23)
	at java.lang.Thread.run(Thread.java:748)
-----hello InterruptDemo03
-----hello InterruptDemo03
-----hello InterruptDemo03
-----hello InterruptDemo03
-----hello InterruptDemo03
-----hello InterruptDemo03
*/

当处于阻塞状态（例如处于sleep, wait, join 等状态）的线程收到中断协商，(在别的线程中调用当前线程对象的interrupt方法)，那么线程将立即退出被阻塞状态且会将中断标识位清除，会直接爆出异常(InterruptedException),但是线程并没有结束。

1 中断标志位默认是false

2 t2 ----->t1发出了中断协商，t2调用t1.interrupt()，中断标志位true

3 中断标志位true，正常情况下，程序停止，^-

4 中断标志位true，异常情况下，InterruptedException，将会把中断状态清除，并且将收到InterruptedException。中断标志位false导致无限循环。

5 在catch块中，需要再次给中断标志位设置为true，2次调用停止

静态方法Thread.interrupted()，谈谈你的理解

public static boolean interrupted()
静态方法，Thread.interrupted();判断线程是否被中断，并清除当前中断状态这个方法做了两件事：

1 返回当前线程的中断状态
2 将当前线程的中断状态设为false（这个方法有点不好理解，因为连续调用两次的结果可能不一样。）

public class InterruptDemo3 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"\t"+Thread.interrupted());
        System.out.println(Thread.currentThread().getName()+"\t"+Thread.interrupted());
        System.out.println("-----1");
        Thread.currentThread().interrupt();//中断标志位设置为true
        System.out.println("-----2");
        System.out.println(Thread.currentThread().getName()+"\t"+Thread.interrupted());
        System.out.println(Thread.currentThread().getName()+"\t"+Thread.interrupted());
    }
}

main	false
main	false
-----1
-----2
main	true
main	false

看下源码，interrupted()对比isInterrupted()

public static boolean interrupted() {
     return currentThread().isInterrupted(true);
}
    
private native boolean isInterrupted(boolean ClearInterrupted);

public boolean isInterrupted() {
     return isInterrupted(false);
}

private native boolean isInterrupted(boolean ClearInterrupted);

他们在底层都调用了native方法isInterrupted。
只不过传入参数ClearInterrupted一个传参传了true，一个传了false。

静态方法interrupted() 中true表示清空当前中断状态。
实例方法isInterrupted 则不会。

LockSupport是什么

官方解释：用于创建锁和其他同步类的基本线程阻塞原语。

核心就是park()和unpark()方法

park()方法是阻塞线程
unpark()方法是解除阻塞线程

线程等待唤醒机制

在我们多线程开发的时候，有时候会有让一些线程先执行的，这些线程结束后，其他线程再继续执行，列如我们生活中打球，球场的每个人都是一个线程，那一个球员必须先传球给另一个球员，那么另一个球员才能投篮，这就是一个线程的一个动作执行完，另一个线程的动作才能执行

使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程
使用JUC包中Condition的wait()方法让线程等待，使用signal()方法唤醒线程
LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程

Object的wait和notify

Wait方法

public final void wait() throws InterruptedException {
   wait(0);
}
public final void wait(long timeout, int nanos) throws InterruptedException {
   if (timeout < 0) {
      throw new IllegalArgumentException("timeout value is negative");
   }
   if (nanos < 0 || nanos > 999999) {
      throw new IllegalArgumentException("nanosecond timeout value out of range");
   }
	if (nanos > 0) {
      timeout++;
    }
	wait(timeout);
}

痴汉方法，死等，线程进入阻塞态（WAITING）,直到有其他线程调用notify方法唤醒
等待一段时间，若再该时间内线程被唤醒，则继续执行，若超过了相应时间还没有其他线程唤醒此线程，此线程不再等待，恢复执行等待方法做的事

等待方法做的事

调用wait方法的前提是获得这个对象的锁（synchronized对象锁，如果有多个线程取竞争这个锁，只有一个线程获得锁，其他线程会处于阻塞队列）
使当前执行代码的线程进行等待 . ( 把线程放到等待队列中 )
调用wait方法会释放锁
满足一定条件会重新尝试获得这个锁，被唤醒的之后不是立即恢复执行，而是进入阻塞队列，竞争锁

结束等待的三个方式

其他线程调用该对象的 notify 方法.
wait 等待时间超时 (wait 方法提供一个带有 timeout 参数的版本, 来指定等待时间).
其他线程调用该等待线程的 interrupted 方法, 导致 wait 抛出 InterruptedException 异常

notify

public final native void notify();
public final native void notifyAll();

notify()随机唤醒一个处在等待状态的线程
notifyAll()唤醒所有处在等待状态的线程
方法notify()也要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。
如果有多个线程等待，则有线程调度器随机挑选出一个呈 wait 状态的线程。(并没有 “先来后到”) 在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步代码块之后才会释放对象锁。

public class ObjectWaitAndNotify {
    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(3L); } catch (InterruptedException e) { e.printStackTrace(); }
        new Thread(()->{
            synchronized (objectLock){
                objectLock.notify();
                System.out.println(Thread.currentThread().getName()+"\t ---发出通知");
            }
        },"t2").start();
    }
}

异常1—去掉synchronized

说明要使用wait和notify必须加synchronized

public class ObjectWaitAndNotify {
    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(3L); } catch (InterruptedException e) { e.printStackTrace(); }
        new Thread(()->{
//            synchronized (objectLock){
                objectLock.notify();
                System.out.println(Thread.currentThread().getName()+"\t ---发出通知");
//            }
        },"t2").start();
    }
}

t1	 ---- come in
Exception in thread "t1" java.lang.IllegalMonitorStateException
	at java.lang.Object.wait(Native Method)
	at java.lang.Object.wait(Object.java:502)
	at com.lsc.day04.ObjectWaitAndNotify.lambda$main$0(ObjectWaitAndNotify.java:20)
	at java.lang.Thread.run(Thread.java:748)
Exception in thread "t2" java.lang.IllegalMonitorStateException
	at java.lang.Object.notify(Native Method)
	at com.lsc.day04.ObjectWaitAndNotify.lambda$main$1(ObjectWaitAndNotify.java:31)
	at java.lang.Thread.run(Thread.java:748)

异常2—把notify和wait的执行顺序对换

说明顺序不能对换

public class ObjectWaitAndNotify{
    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();
    }
}
//一直处于循环中

小总结

wait和notify方法必须要在同步块或者方法里面，且成对出现使用
先wait后notify才OK,顺序

背后工作原理解析

一定要明确锁的资源是谁，引起的竞争的必须是线程调用的锁的对象一定是要一样的，如果竞争的不是同一个锁，那么就不会进入同一个阻塞队列
其只有唤醒线程执行完毕，阻塞队列线程才会有线程能够得到锁
- 阻塞队列和等待队列怎么理解，比如当前t1线程获得了锁资源，那么t2,t3如果想竞争这个锁，t2,t3就得处于阻塞队列，当t1线程得到锁并调用了wait方法进入了等待状态进入等待队列，然后释放了锁资源，那么t2和t3就会去竞争锁资源，然后其中获得一个，依次类推，当三个线程都处于等待队列，当调用了notify线程，等待队列其中线程一个进入阻塞队列，但是阻塞队列就算只有一个线程，也不会立即得到锁，因为执行notify线程也会占用锁，必须等notify线程结束，释放锁
- 如果是调用notifyAll，就会将这三个线程都放入阻塞队列，然后进行竞争锁资源

wait和sleep的区别

其实理论上 wait 和 sleep 完全是没有可比性的，因为一个是用于线程之间的通信的，一个是让线程阻塞一段时间，唯一的相同点就是都可以让线程放弃执行一段时间
如果有共性就先介绍共性，如果没有，分别介绍即可
wait方法是Object类提供的方法，需要搭配synchroized锁来使用，调用wait方法会释放锁，等待线程会被其他线程唤醒或者超时自动唤醒，唤醒之后需要再次竞争synchronized锁才能继续执行
sleep是Thread类提供的方法（不一定要搭配synchronized使用），调用sleep方法进入TIMED_WAITING状态，如果占用锁也不会不会释放锁，时间到了自动唤醒
因为Java锁的目标是对象，而wait需要释放锁，所以针对的目标都是对象，所以把他定义在Object类中，而Sleep()不需要释放锁，所以他针对的目标是线程，所以定义在Thread类中

为什么线程通信的方法 wait(), notify()和 notifyAll()被定义在 Object 类里

Java中锁的目标是对象，Java所有类的都继承了Object，Java想让任何对象都可以作为锁，并且 wait()，notify()等方法用于等待对象的锁或者唤醒线程，在 Java 的线程中并没有可供任何对象使用的锁，所以任意对象调用方法一定定义在Object类中。

为什么 wait(), notify()和 notifyAll()必须在同步方法或者同步块中被调用

当一个线程需要调用对象的 wait()方法的时候，这个线程必须拥有该对象的锁，接着它就会释放这个对象锁并进入等待状态（等待队列）直到其他线程调用这个对象上的 notify()方法。
同样的，当一个线程需要调用对象的 notify()方法时，它会释放这个对象的锁（在执行完锁的代码内容），以便其他在等待的线程就可以得到这个对象锁。
由于所有的这些方法都需要线程持有对象的锁，这样就只能通过同步来实现，所以他们只能在同步方法或者同步块中被调用。

Condition接口中的await和signal

public class ConditionAwaitAndSignal {
    public static void main(String[] args) {
        ReentrantLock 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();
            }catch (Exception e){
                e.printStackTrace();
            }
            finally {
                lock.unlock();
            }
            System.out.println(Thread.currentThread().getName()+"\t"+"我要进行唤醒");
        },"t2").start();
    }
}

异常1原理同上

仍然返回IllegalMonitorStateException

异常2 原理同上

仍然在不停的循环

小总结

await和notify类似于上面wait和notify
Condition中的线程等待和唤醒方法，需要先获取锁
一定要先await后signal，不能反了

Object和Condition使用的限制条件

总结

线程先要获得并持有锁，必须在锁块（synchronized或lock）中
必须要先等待后唤醒，线程才能够被唤醒

LockSupport类中的park等待和unpark唤醒

是什么

通过park()和unpark(thread)方法来实现阻塞和唤醒线程的操作

官网解释

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

阻塞

park()/park(Object blocker)

调用LockSupport.park()时，发现它调用了unsafe类，并且默认传了一个0

public static void park() {
     UNSAFE.park(false, 0L);
}
public native void park(boolean var1, long var2);

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

唤醒

调用LockSupport.unpark();时，也调用了unsafe类

public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
}
public native void unpark(Object var1);

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

public class LockSupportParkAndUnPark {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"\t----------come in");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName()+"\t----------被唤醒了");
        }, "t1");
        t1.start();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"\t----------come in");
            LockSupport.unpark(t1);
            System.out.println(Thread.currentThread().getName()+"\t----------我来唤醒了");
        }, "t2").start();
    }
}
t1	----------come in
t2	----------come in
t2	----------我来唤醒了
t1	----------被唤醒了

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

public class LockSupportParkAndUnPark {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"\t----------come in");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            LockSupport.park();
            System.out.println(Thread.currentThread().getName()+"\t----------被唤醒了");
        }, "t1");
        t1.start();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"\t----------come in");
            LockSupport.unpark(t1);
            System.out.println(Thread.currentThread().getName()+"\t----------我来唤醒了");
        }, "t2").start();
    }
}
t1	----------come in
t2	----------come in
t2	----------我来唤醒了
t1	----------被唤醒了

sleep方法3秒后醒来，执行park无效，没有阻塞效果，解释如下。先执行了unpark(t1)导致上面的park方法形同虚设无效，时间是一样的

类似于高速公路的ETC，提前买好了通行证unpark，到闸机处直接抬起栏杆放行了，没有park拦截了。

public class LockSupportDemo
{
    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"+"\t"+System.currentTimeMillis());
            LockSupport.park();
            LockSupport.park();
            System.out.println(Thread.currentThread().getName()+"\t----------被唤醒了"+"\t"+System.currentTimeMillis());
        },"t1");
        t1.start();

        new Thread(()->{
            LockSupport.unpark(t1);
            LockSupport.unpark(t1);
            System.out.println(Thread.currentThread().getName()+"\t-----发出通知，去唤醒t1");
        },"t2").start();
    }
}
//t2  -----发出通知，去唤醒t1
//t1  ----------come in  1654750970677--------------------卡在这里了

一个线程的通行证只能有一个

小总结

Lock Support是用来创建锁和其他同步类的基本线程阻塞原语。
Lock Support是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法。归根结底， Lock Support调用的Unsafe中的native代码。
Lock Support提供park() 和unpark() 方法实现阻塞线程和解除线程阻塞的过程
Lock Support和每个使用它的线程都有一个许可(permit) 关联。
每个线程都有一个相关的permit， permit最多只有一个，重复调用unpark也不会积累凭证。

面试题
为什么可以突破wait/notify的原有调用顺序?

因为unpark获得了一个凭证，之后再调用park方法，就可以名正言顺的凭证消费，故不会阻塞。
先发放了凭证后续可以畅通无阻。

为什么唤醒两次后阻塞两次，但最终结果还会阻塞线程?文章来源地址https://uudwc.com/A/jRvY

因为凭证的数量最多为1，连续调用两次unpark和调用一次unpark效果一样，只会增加一个凭证；而调用两次park却需要消费两个凭证，证不够，不能放行。