Java 机场同步-线程卡住

我想给机场监视器编码（飞机试图到达，飞机试图起飞，等等），我有点问题。只有一个线程似乎在工作，其他线程被卡在某个地方。有人能看一下这个代码并提供帮助吗

public class Lotniskowiec {

public int K=5;
public int N = 10;

final Lock lock = new ReentrantLock();
final Condition toStart  = lock.newCondition(); 
final Condition toLand= lock.newCondition(); 
 boolean wantsToStart;
 boolean wantsToLand;
 int atAirport= 0;
boolean free= true;

private  void free_landing_area(){

        lock.lock();
    if(atAirport< K){
        if(wantsToLand){
            toLand.signal();
        }else toStart.signal();
    }
    else{
        if(wantsToStart){
        toStart.signal();
        } else if (atAirport< N){
            toLand.signal();
        }
    }       
        lock.unlock();
}

public  void wants_to_start(){

    lock.lock();
    if(!free){
        lock.unlock();
        try {
            toStart.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    lock.lock();
    free=false;
    lock.unlock();


}

public void started(){

    lock.lock();
    atAirport-=1;
    free=true;

    free_landing_area();
    lock.unlock();

}

public void wants_to_land(){

        lock.lock();
    if(!free|| atAirport==N){
        lock.unlock();
        try {
            toLand.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    lock.lock();
    free=false;
    lock.unlock();
}

public void landed(){

    lock.lock();
    atAirport+=1;
    free=true;

    free_landing_area();
    lock.unlock();  
}
}

开始线程：

Samolot r = new Samolot(1,lotniskowiec);
    Thread t = new Thread(r);
    t.start();

好的，这是线索： 其他线程被锁定在toLand.await（）语句的wants_to_land方法中。 signal（）永远不会发生，因为if（wantsToLand）和if（wantsToStart）总是错误的（在任何地方都不会更改）。

---

考虑刷新同步逻辑，看看是否有帮助。

< p>你的代码> WANSDSY-toLand 和<代码> WANSDSY-ToSTEng/<代码>是布尔代数，但它们应该是整数。否则，你将如何跟踪有多少飞机希望着陆

此外，我认为在平面调用的每个方法的开头使用

lock.lock（）

，在结尾使用

lock.unlock（）。在您当前的代码中，飞机获得锁的次数比释放锁的次数要多，从而有效地从其他飞机上窃取锁

此外，它可能有助于使锁公平

所以

公共静态int K=5；
公共静态int N=10；
最终静态锁=新的可重入锁（真）；
最终静态条件toStart=lock.newCondition（）；
最终静态条件toLand=lock.newCondition（）；
静态int wantsToStart=0；
静态int wantsToLand=0；
静态int-atAirport=0；
静态布尔自由=真；
专用静态无空隙着陆区（）{
if（atAirport0）{
toLand.signal（）；
}否则{
toStart.signal（）；
}
}否则{
如果（wantsToStart>0）{
toStart.signal（）；
}else if（atAirport

最后，我认为您实际上需要在while循环中等待（），因为在某些情况下线程可能会被意外唤醒

在等待某个条件时，允许执行“虚假唤醒”
通常，作为对基础平台的让步而发生
语义学。这对大多数应用程序几乎没有实际影响
作为条件的程序应始终在循环中等待，
正在测试正在等待的状态谓词

因此，上面的代码还不完全存在。但这并不是让线程陷入困境的原因。
请重构名称，但这并不意味着代码变得更难阅读。我是否认为线程本身的代码仍然缺失？我已经添加了这一点，但我很确定问题出在监视器中；）你最好快点；飞机正在你的机场上空盘旋，燃油不足！灾难发生了；）在修复了所有这些并实际更改了wantsToStart和WantsToLearn之后，它成功了。谢谢！：）
Samolot r = new Samolot(1,lotniskowiec);
    Thread t = new Thread(r);
    t.start();

    public static int K = 5;
    public static int N = 10;

    final static Lock lock = new ReentrantLock(true);
    final static Condition toStart = lock.newCondition();
    final static Condition toLand = lock.newCondition();
    static int wantsToStart = 0;
    static int wantsToLand = 0;
    static int atAirport = 0;
    static boolean free = true;

    private static void free_landing_area() {
        if (atAirport < K) {
            if (wantsToLand > 0) {
                toLand.signal();
            } else {
                toStart.signal();
            }
        } else {
            if (wantsToStart > 0) {
                toStart.signal();
            } else if (atAirport < N) {
                toLand.signal();
            }
        }
    }

    public static void wants_to_start() {
        lock.lock();
        if (!free) {
            try {
                wantsToStart++;
                toStart.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        free = false;
        lock.unlock();
    }

    public static void started() {
        lock.lock();
        atAirport -= 1;
        free = true;
        wantsToStart--;
        free_landing_area();
        lock.unlock();
    }

    public static void wants_to_land() {
        lock.lock();
        if (!free || atAirport == N) {
            try {
                wantsToLand++;
                toLand.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        free = false;
        lock.unlock();
    }

    public static void landed() {
        lock.lock();
        atAirport += 1;
        free = true;
        wantsToLand--;
        free_landing_area();
        lock.unlock();
    }