等待/通知死锁

Question

我有一个队列，在“添加”和“获取”方法中具有一些阻塞机制，其中第一个线程添加数据，第二个线程获取数据。

public synchronized MyObj getData() {               
    synchronized (myLock) {
        synchronized (this) {
            if (isEmpty()) {                
                wait(0);                    
            }
        }       


        return getData();           
    }
}

public synchronized void addData(MyObj data) {
    if (!isFull()) {
        putData(data);
        synchronized (this) {
            notify();
        }
    }
}

在上面的代码中，如果第一个线程尝试获取数据并且队列为空，我将通过 wait(0) 进行等待，直到其他线程将数据添加到队列中，然后通过 notification() 释放等待。

现在，当队列已满并且有人尝试向其中添加更多数据时，我想添加另一个“锁”：

public synchronized MyObj getData() {               
    synchronized (myLock) {
        synchronized (this) {
            if (isEmpty()) {                
                wait(0);                    
            }
        }       

        synchronized (this) {
            notify();
        }
        return getData();           
    }
}

public synchronized void addData(MyObj data) {
    synchronized (myLock) {
        synchronized (this) {
            if (isFull()) {
                wait(0);
            }
        }
    }

    synchronized (this) {
        notify();
        }
        PutData(data);
}

结果不是我所期望的，我猜我得到了死锁，因为进程被卡住了。

更新

这就是我获取数据的方式：

queueSize--;
startPointer = (startPointer + 1) % mqueueSize;
data = (String) queue[startPointer];

这就是我添加数据的方式

  queueSize++;
  endPointer = (endPointer + 1) % mqueueSize;
  queue[endPointer] = data;

public synchronized boolean isEmpty() {
        return queueSize== 0;
    }

    public synchronized boolean isFull() {
        return queueSize== mqueueSize;
    }

Answer 1

为什么有三个synchronized语句？ wait(0) 仅释放 this 上的锁，因此只需保留该锁并从方法和 中转储 synchronized同步（myLock）。

每当您对某个对象调用 wait（在本例中您正在调用 this）时，该对象上的锁就会自动释放，以允许其他线程继续进行。但是您永远不会在 myLock 上调用 wait （也不应该，因为您已经在调用 this 了）。该部分是多余的并导致死锁。

考虑这种情况：应该添加的线程获取了 myLock 上的锁，但发现队列已满，因此它等待。此等待不会释放 myLock 上的锁定。另一个线程想要获取数据，但无法进入 synchronized 块，因为第一个线程没有释放 myLock 上的锁。

结论：删除 synchronized(myLock) 块。

Answer 2

为什么你不看看java.lang. util.BlockingQueue。也许它对您的情况有用。

特别是看看 java.util.LinkedBlockingQueue，如果您在构造函数中指定队列的容量，则队列将阻塞。

Answer 3

从方法签名中删除 synchronized 关键字，因为这意味着您持有整个方法调用的 this 监视器 - synchronized(this)块只是多余的。

编辑：

...然后在 myLock 而不是 this 上调用 wait 和通知。并且完全忘记在 this 上进行同步。这是因为在等待时（在当前代码中的 this 上），您没有释放 myLock 锁，因此其他线程无法访问 通知（）。

Answer 4

将 if 替换为 while。如果集合确实变得不空/不满，那么仔细检查不会有什么坏处。

你真的不需要两把锁。单锁几乎也可以工作，而且应该简单得多。

public synchronized T get()
{
    while(isEmpty())
        wait(0);

    notifyAll();

    return super.get();

}

public synchronized put(T t)
{

    while(isFull())
        wait(0);

    super.put(t);

    notifyAll();

}

当事情发生变化时，所有线程都会被唤醒。但如果他们无法完成工作，他们将等待下一个通知。

Answer 5

正如已经提到的，您的代码有太多synchronized 注释。此外，wait 的条件是在 if 条件中检查的，但理想情况下应该在 while 循环中检查，以避免 虚假唤醒。以下是修复这些问题的代码概要。

// _isEmpty and _getData are private unsynchronized methods
public MyData get() throws InterruptedException {
  // wait and notify should be called from a block
  // synchronized on the same lock object (here myLock)       
  synchronized (myLock) {
    // the condition should be tested in a while loop
    // to avoid issues with spurious wakeups
    while (_isEmpty()) {
      // releases the lock and wait for a notify to be called
      myLock.wait();
    }
    // when control reaches here, we know for sure that
    // the queue is not empty
    MyData data = _getData();
    // try to wake up all waiting threads - maybe some thread
    // is waiting for the queue not to be full
    myLock.notifyAll();
  }
}

// _isFull and _putData are private unsynchronized methods
public void put(MyData obj) throws InterruptedException {
  synchronized (myLock) {
    while (_isFull()) {
      myLock.wait();
    }
    _putData(obj);
    myLock.notifyAll();
  }
}