import java.util.concurrent.locks.LockSupport;
public class LockSupportDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + ": 开始执行，即将被阻塞...");
            // 1. park() - 阻塞当前线程
            // 如果此时有许可证，则消耗掉许可证并继续运行；如果没有，则等待。
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + ": 被唤醒了，继续执行！");
        }, "示例线程");
        thread.start();
        // 主线程睡眠2秒，确保子线程先执行并先调用park()
        Thread.sleep(2000);
        System.out.println(Thread.currentThread().getName() + ": 准备唤醒子线程");
        // 2. unpark(Thread thread) - 唤醒指定的线程
        // 给`thread`线程发放一个许可证（如果它还没有的话）。
        LockSupport.unpark(thread);
    }
}

示例线程: 开始执行，即将被阻塞...
main: 准备唤醒子线程
示例线程: 被唤醒了，继续执行！

import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.atomic.AtomicReference;
/**
 * 一个基于LockSupport的简易互斥锁（不可重入）
 */
public class MiniLock {
    // 使用原子引用，记录当前持有锁的线程
    private final AtomicReference<Thread> owner = new AtomicReference<>();
    // 等待队列，这里简单使用链表结构。AQS中是一个真正的CLH队列
    private volatile Node waiters;
    private static class Node {
        final Thread thread;
        volatile Node next;
        Node(Thread thread) {
            this.thread = thread;
        }
    }
    public void lock() {
        Thread current = Thread.currentThread();
        // 尝试通过CAS获取锁
        while (!owner.compareAndSet(null, current)) {
            // 获取失败，将自己加入等待队列
            Node node = new Node(current);
            node.next = waiters;
            waiters = node;
            // 然后park自己
            LockSupport.park(this); // 传入this作为blocker
            // 被唤醒后，并不代表立刻拿到锁了，需要重新进入循环尝试CAS
        }
        // 成功获取锁，退出方法
    }
    public void unlock() {
        Thread current = Thread.currentThread();
        if (owner.compareAndSet(current, null)) {
            // 释放锁成功，需要唤醒等待队列中的一个线程
            if (waiters != null) {
                // 这里简单唤醒队列中的第一个线程（非公平锁策略）
                Node first = waiters;
                if (first != null) {
                    waiters = first.next; // 从队列中移除
                    LockSupport.unpark(first.thread); // 唤醒它
                }
            }
        }
    }
    // 测试我们的MiniLock
    private static int count = 0;
    private static final MiniLock lock = new MiniLock();
    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            for (int i = 0; i < 10000; i++) {
                lock.lock();
                try {
                    count++;
                } finally {
                    lock.unlock();
                }
            }
        };
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Final count: " + count); // 正确输出 20000
    }
}