Java 可以使用独占锁实现倒计时闩锁吗？

JDK1.8的源代码是由AQS共享锁实现的。使用共享锁的注意事项是什么？为什么不使用独占锁？以下是我的专用锁实现的代码：

public class MyCountDownLatch {
private static final class Sync extends AbstractQueuedSynchronizer {
    Sync(int count) {
        setState(count);
    }
    int getCount() {
        return getState();
    }
    protected boolean tryAcquire(int acquires) {
        return (getState() == 0) ? true :false;
    }
    protected boolean tryRelease(int releases) {
        // Decrement count; signal when transition to zero
        for (;;) {
            int c = getState();
            if (c == 0)
                return false;
            int nextc = c-1;
            if (compareAndSetState(c, nextc))
                return nextc == 0;
        }
    }
}
private final MyCountDownLatch.Sync sync;
public MyCountDownLatch(int count) {
    this.sync = new MyCountDownLatch.Sync(count);
}
public void await() throws InterruptedException {
    sync.acquireInterruptibly(1);
}
public void countDown() {
    sync.release(1);
}
public static void main(String[] args) throws InterruptedException {
    MyCountDownLatch myCountDownLatch = new MyCountDownLatch(5);
    for(int i=0;i<5;i++){
        new Thread(()-> {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"start");
            myCountDownLatch.countDown();
        }).start();
    }
    myCountDownLatch.await();
    System.out.println("finished");

}

公共类MyCountDownLatch{
私有静态最终类同步扩展AbstractQueuedSynchronizer{
同步（整数计数）{
设置状态（计数）；
}
int getCount（）{
返回getState（）；
}
受保护的布尔值tryAcquire（整数获取）{
返回（getState（）==0）？true:false；
}
受保护的布尔tryRelease（int版本）{
//减量计数；转换为零时的信号
对于（；；）{
int c=getState（）；
如果（c==0）
返回false；
int-nextc=c-1；
如果（比较设置状态（c，nextc））
返回nextc==0；
}
}
}
私有的最后一个MyCountDownLatch.Sync；
公共关闭闩锁（整数计数）{
this.sync=新的MyCountDownLatch.sync（计数）；
}
public void await（）引发InterruptedException{
可中断同步（1）；
}
公共空间倒计时（）{
同步发布（1）；
}
公共静态void main（字符串[]args）引发InterruptedException{
MyCountDownLatch MyCountDownLatch=新的MyCountDownLatch（5）；
对于（int i=0；i{
试一试{
睡眠（200）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
System.out.println（Thread.currentThread（）.getName（）+“start”）；
myCountDownLatch.countDown（）；
}).start（）；
}
myCountDownLatch.await（）；
系统输出打印项次（“完成”）；
}

---

}好吧，

共享锁

意味着可以有多个线程等待完成。如果您使用

独占锁实现它

，那么您只能等待1个线程。

您没有附加任何代码请提供代码的相关部分。添加一个包含正确输入/输出数据的示例。错误404：未找到代码。我已提交代码。谢谢