AQS DEMO

@Test
public void Test() {
  ReentrantLock reentrantLock = new ReentrantLock();//非公平锁

  // A B C三个顾客，去银行办理业务，A先到，此时窗口空无一人，他优先获得办理窗口的机会，办理业务。
  // A 耗时严重，估计长期占有窗口
  new Thread(() -> {
    reentrantLock.lock();
    try
    {
      System.out.println("----come in A");
      //暂停20s线程
      try { TimeUnit.SECONDS.sleep(32); } catch (InterruptedException e) { e.printStackTrace(); }
    }finally {
      reentrantLock.unlock();
    }
  },"A").start();

  //B是第2个顾客，B一看到受理窗口被A占用，只能去候客区等待，进入AQS队列，等待着A办理完成，尝试去抢占受理窗口。
  new Thread(() -> {
    reentrantLock.lock();
    try
    {
      System.out.println("----come in B");
      try { TimeUnit.SECONDS.sleep(16); } catch (InterruptedException e) { e.printStackTrace(); }
    }finally {
      reentrantLock.unlock();
    }
  },"B").start();


  //C是第3个顾客，C一看到受理窗口被A占用，只能去候客区等待，进入AQS队列，等待着A办理完成，尝试去抢占受理窗口,前面是B顾客，FIFO
  new Thread(() -> {
    reentrantLock.lock();
    try
    {
      System.out.println("----come in C");
      try { TimeUnit.SECONDS.sleep(8); } catch (InterruptedException e) { e.printStackTrace(); }
    }finally {
      reentrantLock.unlock();
    }
  },"C").start();

  new Thread(() -> {
    reentrantLock.lock();
    try
    {
      //。。。。。。
      System.out.println("----come in D");
      try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { e.printStackTrace(); }
    }finally {
      reentrantLock.unlock();
    }
  },"D").start();


  while (reentrantLock.isLocked()) {
    try { TimeUnit.MILLISECONDS.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }
    int queueLength = reentrantLock.getQueueLength();

    System.out.println("当前正在排队的人数queueLength:"+queueLength+"    "+"当前持有锁的线程是："+reentrantLock.toString());
  }
}

// 演示锁的实现
class Mutex implements java.io.Serializable {
    //静态内部类，继承AQS
    private class Sync extends AbstractQueuedSynchronizer {
        //是否处于占用状态
        @Override
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }
        //当状态为0的时候获取锁，CAS操作成功，则state状态为1，
        @Override
        public boolean tryAcquire(int acquires) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
        //释放锁，将同步状态置为0
        @Override
        protected boolean tryRelease(int releases) {
            if (getState() == 0) {
                throw new IllegalMonitorStateException();
            }
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }
    }
    //同步对象完成一系列复杂的操作，我们仅需指向它即可
    private final Sync sync = new Sync();
    //加锁操作，代理到acquire（模板方法）上就行，acquire会调用我们重写的tryAcquire方法
    public void lock() {
        sync.acquire(1);
    }
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }
    //释放锁，代理到release（模板方法）上就行，release会调用我们重写的tryRelease方法。
    public void unlock() {
        sync.release(1);
    }
    public boolean isLocked() {
        return sync.isHeldExclusively();
    }
}

@Test
public void Test02() {
    Mutex mutex = new Mutex();

    Runnable task = () -> {
        System.out.println(Thread.currentThread().getName() + " is trying to lock...");
        mutex.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " has locked.");
            // 模拟一些需要同步执行的任务
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            System.out.println(Thread.currentThread().getName() + " is unlocking.");
            mutex.unlock();
        }
    };

    Thread thread1 = new Thread(task, "Thread-1");
    Thread thread2 = new Thread(task, "Thread-2");

    thread1.start();

    thread2.start();

    // 确保thread1先运行并获取锁
    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

// 演示wait notify 
class BooleanLatch {
    private class Sync extends AbstractQueuedSynchronizer {
        boolean isSignalled() { return getState() != 0; }
        protected int tryAcquireShared(int ignore) {
            return isSignalled() ? 1 : -1;
        }
        protected boolean tryReleaseShared(int ignore) {
            setState(1);
            return true;
        }
    }
    private final Sync sync = new Sync();
    public boolean isSignalled() {
        return sync.isSignalled();
    }
    public void signal() {
        sync.releaseShared(1);
    }
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
}


@Test
public void Test() throws InterruptedException {
    BooleanLatch latch = new BooleanLatch();

    // 创建一个线程来等待信号
    Thread waiterThread = new Thread(() -> {
        System.out.println("Waiter thread is waiting...");
        try {
            latch.await();
            System.out.println("Waiter thread has been signalled!");
        } catch (InterruptedException e) {
            System.out.println("Waiter thread was interrupted.");
        }
    });

    // 启动等待线程
    waiterThread.start();

    // 主线程休眠一段时间，模拟一些工作
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    // 发送信号
    System.out.println("Main thread is signalling...");
    latch.signal();

    // 等待等待线程结束
    try {
        waiterThread.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    // 检查信号状态（仅用于演示）
    System.out.println("Latch signalled state: " + latch.isSignalled());
}