1

试图锻炼我对 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--;
  }
}

当它运行时，它挂起。我怀疑是死锁，我也不知道这个问题需要多少级同步。这可以只用一个级别来完成吗？

4

1 回答 1

0

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

在这种情况下，您有一个线程正在等待Boolean.TRUE，另一个线程在 上发布通知Boolean.FALSE。

于 2013-02-14T03:52:56.120 回答