Java 相邻同步块

出于学术目的，我正在尝试使用低级机制实现类似于Java高级锁的东西

我想实现一种不同的语义，在这种语义中，信号器线程必须等待，直到信号器终止其关键区域，但是当信号器终止时，信号器具有优先权以获得锁

我的疑问如下：在所附的代码中，两个相邻的同步块的存在是一个问题吗

我尝试在同步部分中使用修改的布尔值来解决问题，但是由于部分锁定了不同的内容，我不确定这个解决方案

public class FIFOLock {
    private final Queue<QueueElement> entrySet;
    private boolean busy;
    private Thread owner;
    protected Queue<Object> urgentQueue;

    public FIFOLock() {
        this.entrySet = new LinkedList();
        this.urgentQueue = new LinkedList();
        this.busy = false;
        this.owner = null;
    }

    public void lock() throws InterruptedException {
        QueueElement queued;

        synchronized (this) {
            if ((owner != null) && (owner.equals(Thread.currentThread())))
                return; /* Lock already achieved */

            if (!busy) {
                busy = true;
                this.owner = Thread.currentThread();
                System.out.println("LockOwner:  " + Thread.currentThread().getName());
                // System.out.println("FREE");
                return;
            }

            queued = new QueueElement(true);
            entrySet.add(queued);

        }
        synchronized (queued) {
            if (queued.isWaiting())
                queued.wait();
            this.owner = Thread.currentThread();
        }
    }

    public void unlock() throws InterruptedException {
        Object urgentElement = new Object();
        QueueElement entryElement = new QueueElement(false);
        boolean urgent = false;
        synchronized (this) {

            if (urgentQueue.size() != 0) {
                urgentElement = urgentQueue.poll();
                urgent = true;

            } else {
                if (entrySet.size() == 0) {
                    busy = false;
                    return;
                }
                entryElement = entrySet.poll();
            }
        }
        if (urgent) {
            synchronized (urgentElement) {
                urgentElement.notify();
            }
        } else {
            synchronized (entryElement) {
                owner = null;
                if (entryElement.isWaiting())
                    entryElement.notify();
                entryElement.setWaiting(false);
            }
        }
    }
}

公共类FIFOLock{
私有最终队列入口集；
私人布尔忙；
私有线程所有者；
受保护队列；
公共FIFOLock（）{
this.entrySet=newLinkedList（）；
this.urgentQueue=new LinkedList（）；
this.busy=false；
this.owner=null；
}
public void lock（）引发InterruptedException{
排队元素排队；
已同步（此）{
if（（owner！=null）&&（owner.equals（Thread.currentThread（）））
return；/*已实现锁定*/
如果（！忙）{
忙=真；
this.owner=Thread.currentThread（）；
System.out.println（“锁所有者：+Thread.currentThread（）.getName（））；
//System.out.println（“免费”）；
回来
}
queued=新的QueueElement（true）；
添加（排队）；
}
已同步（排队）{
if（queued.isWaiting（））
wait（）；
this.owner=Thread.currentThread（）；
}
}
public void unlock（）引发InterruptedException{
Object UrgenElement=新对象（）；
QueueElement entryElement=新的QueueElement（false）；
布尔紧急=假；
已同步（此）{
如果（urgentQueue.size（）！=0）{
urgenelement=urgentQueue.poll（）；
紧急=正确；
}否则{
if（entrySet.size（）==0）{
忙=假；
回来
}
entryElement=entrySet.poll（）；
}
}
如有需要（紧急）{
已同步（urgenelement）{
urgenelement.notify（）；
}
}否则{
已同步（entryElement）{
所有者=空；
if（entryElement.isWaiting（））
entryElement.notify（）；
entryElement.setWaiting（false）；
}
}
}
}

此代码在同步方面似乎是安全的。但这很难理解，所以我不敢打赌。现在我看到的更重要的问题是，如果线程A获得了锁，那么任何其他线程B都可以释放该锁。释放锁时，不检查线程拥有情况。我也不知道紧急队列是如何修改的。正确地实现锁是很困难的，所以我希望有一些细微的错误。好的，谢谢你的观察，我同意你的观点，需要检查释放锁的线程。对于紧急队列，线程只能保留在此队列中，作为对相关FIFOCondition类的影响，该类未附加在本文中。信号后的线程在该队列上保持阻塞状态，该线程在entrySet上具有优先级。您应该始终将

wait（）

call放入循环中。看。