Java:在此示例中防止死锁

Question

尝试锻炼我对 Java 并发性的理解，问题如下:可以有多个线程运行方法 A，而只有一个线程运行方法 B(假设 A() 运行了 10 次。因此，第 10 次，该线程将运行方法 B。当发生这种情况时，它必须阻止线程运行 A 并允许已运行 A 的线程在运行 B 的其余部分之前完成。此外，A 中的线程不应自行等待。

编辑:所有线程首先在 A 上启动，有一个外部方法检查何时运行 B。

到目前为止我的尝试看起来像这样:

volatile Boolean lock = false; //false = threads in method A allowed to run, thread in method B otherwise
volatile Integer countOfA = 0;

void A(){
    boolean continue = false;
    synchronized(lock){
    if(lock == true){ //there is a thread in B, block threads in A
        lock.wait();

        increaseCountOfA();
        //do work
        decreaseCountOfA();

        if(countOfA == 0){ //this was the last thread that ran with lock
            lock = true;
            lock.notify(); //only the thread in B should be waiting on this
        }
      }else{
        continue = true;
      }
    }

    if(continue){
        increaseCountOfA();
        //do work;
        decreaseCountOfA();
    }
}

void B(){
  synchronized(lock){
    if(lock == false){
        lock.wait();
        if(countOfA > 0){
            countOfA.wait();
        }
        //do work;
        lock = false;
        lock.notifyAll();
    }
  }
}

void increaseCountOfA(){
  synchronized(countOfA){
    countOfA++;
  }
}

void decreaseCountOfA(){
  synchronized(countOfA){
    countOfA--;
  }
}

当它运行时，它会挂起。我怀疑出现死锁，而且我不知道这个问题需要多少级同步。只用一层就可以做到这一点吗？

Answer 1

当您执行synchronized(lock)时，您正在同步lock引用的对象，而不是变量。您可能需要一个独立的锁对象，您不更改其值。或者，您可以考虑使用更高级别的并发类，例如 Semaphore。

在本例中，您有一个线程在 Boolean.TRUE 上等待，另一个线程在 Boolean.FALSE 上发布通知。