JUC-3

public class ReentrantLock implements Lock, java.io.Serializable {
    private final Sync sync;
    abstract static class Sync extends AbstractQueuedSynchronizer {...}
    static final class NonfairSync extends Sync {...}
    static final class FairSync extends Sync {...}
    ...
}

/*
这是 jdk21 的新增方法，是个抽象方法，由公平锁和非公平锁各自实现，
主要作用就是减少进入 AQS 队列的开销，能直接抢到就直接抢。后面细说。
*/
abstract boolean initialTryLock();

/*
也和之前的调用链对应上了，先调 initialtryLock()，
失败了抛给 AQS 的 acquire(1)。
*/
final void lock() {
    if (!initialTryLock())
        acquire(1);
}

/*
这个方法专门给外层 tryLock() API 用，不走 AQS 排队机制。
*/
final boolean tryLock() {
    Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        //直接 CAS 0->1，成功就返回 true，重入就 state++
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(current);
            return true;
        }
        //如果当前线程就是独占锁的线程，说明重入。
    } else if (getExclusiveOwnerThread() == current) {
        if (++c < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(c);
        return true;
    }
    return false;
}

/*
Sync 重写 AQS 的钩子，
由 sync.release(1) 调用，release 内部会回调 tryRelease
*/
protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    //先检查当前线程是不是持有锁的线程
    if (getExclusiveOwnerThread() != Thread.currentThread())
        throw new IllegalMonitorStateException();
    //state 减到0才算真正释放
    boolean free = (c == 0);
    if (free)
        setExclusiveOwnerThread(null);
    setState(c);
    return free;
}

/*
可 中断获取 锁的底层实现
*/
final void lockInterruptibly() throws InterruptedException {
    //如果被中断，直接抛异常
    if (Thread.interrupted())
        throw new InterruptedException();
    //快速尝试获取锁（不排队不阻塞）
    if (!initialTryLock())
        //快速路径失败，进入 AQS 的完整排队 + 阻塞流程
        acquireInterruptibly(1);
}
/*
限时获取锁的底层实现
*/
final boolean tryLockNanos(long nanos) throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    //快速尝试，失败则进入 AQS 的
    //限时排队流程（最多等nanos 纳秒，超时返回false，线程继续执行后续代码）
    return initialTryLock() || tryAcquireNanos(1, nanos);
}

static final class NonfairSync extends Sync {
    /*
    initialTryLock() 是一个“快速路径”，
    它把无竞争获取和重入这两种最常见、最廉价的情况一次性处理掉，
    避免进入 AQS 的队列和阻塞逻辑。
    只有在锁确实被其他线程占用时，才走重量级流程。
    */
    final boolean initialTryLock() {
        Thread current = Thread.currentThread();
        //插队行为
        if (compareAndSetState(0, 1)) { // first attempt is unguarded
            setExclusiveOwnerThread(current);
            return true;
        } else if (getExclusiveOwnerThread() == current) {
            int c = getState() + 1;
            if (c < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            setState(c);
            return true;
        } else
            return false;
    }
    /**
     * Acquire for non-reentrant cases after initialTryLock prescreen
     */
    //上边的原始注释也说了，在 initialTryLock 预筛选后，用于处理非重入情况。
    //acquire(1) 会调用 tryAcquire(1)，
    //此时当前线程一定不是锁的持有者（如果是就走 initialTryLock() 了）
    protected final boolean tryAcquire(int acquires) {
        if (getState() == 0 && compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        //不处理重入，因为在上面函数处理过了
        //不检查等待队列，因为非公平锁允许插队。
        return false;
    }
}

static final class FairSync extends Sync {
    /**
     * Acquires only if reentrant or queue is empty.
     */
    final boolean initialTryLock() {
        Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (!hasQueuedThreads() && compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        } else if (getExclusiveOwnerThread() == current) {
            if (++c < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            setState(c);
            return true;
        }
        return false;
    }

    /**
     * Acquires only if thread is first waiter or empty
     */
    //上面说 仅当当前线程是队首或者队列为空时才会获取。
    //hasQueuedThreads() = 队列里有没有人？
    //hasQueuedPredecessors() = 我前面有没有人？
    //后者考虑到到了当前线程是队首的情况
    protected final boolean tryAcquire(int acquires) {
        if (getState() == 0 && !hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }
}

class SemaphoreExample {
    Semaphore parking = new Semaphore(3);
    public void park() {
        for (int i = 0; i < 10; i++) {
            int carId = i;
            new Thread(() -> {
                try {
                    parking.acquire();
                    System.out.println("车辆：" + carId +
                            "停入，剩余车位：" + parking.availablePermits());
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    parking.release();
                    System.out.println("车辆：" + carId +
                            "离开，剩余车位：" + parking.availablePermits());
                }
            }).start();
        }
    }
}

class CountDownLatchExample {
    String[] resources = new String[]{"map", "role"};
    CountDownLatch pubg = new CountDownLatch(resources.length);
    public void load() throws InterruptedException {
        for (String resource : resources) {
            new Thread(() -> {
                try {
                    Thread.sleep(2000);
                    System.out.println(resource + "加载完成");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    pubg.countDown();
                }
            }).start();
        }
        System.out.println("等待资源加载中");
        pubg.await();
        System.out.println("资源加载完成，上飞机。");
    }
}

public class BlockingQueueProducerConsumer {
    private static final BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);
    private static final Random rand = new Random();
    public static void main(String[] args) {
        Thread producer = new Thread(() -> {
            while (true) {
                try {
                    int value = rand.nextInt(100);
                    queue.put(value);
                    System.out.println("produce:" + value + ", queue.size = " + queue.size());
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });

        Thread consumer = new Thread(() -> {
            while (true) {
                try {
                    Integer value = queue.take();
                    System.out.println("consume:" + value + ", queue.size = " + queue.size());
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });
        producer.start();
        consumer.start();
    }
}

public void run() {
    while (!Thread.currentThread().isInterrupted()) {
        try {
            // 干活
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // 不能继续抛 InterruptedException 时，恢复中断状态
            Thread.currentThread().interrupt();
            // 停止当前循环/任务
            break;
        }
    }
    // 清理资源
}

class MeiTuanTest {
    public void print1() {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
        AtomicInteger i = new AtomicInteger(1);
        long start = System.currentTimeMillis();
        Thread p = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    Thread.sleep(100);
                    System.out.println("-------- " + (System.currentTimeMillis() - start) + "ms ----------");
                    int value = i.getAndIncrement();
                    queue.put(value);
                    System.out.println("p: " + value);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });
        Thread c = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    Thread.sleep(300);
                    List<Integer> list = new ArrayList<>();
                    queue.drainTo(list);
                    System.out.println("c: " + list.toString());
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });
        p.start();
        c.start();
    }
}

public void doWork(Executor executor) {
    executor.execute(() -> System.out.println("任务执行"));
}

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {...}