使用 .wait 和 .notify 进行对象池

Question

我正在尝试在 java 中创建一个池对象的类。该类开始创建所需的最小数量的对象，当请求开始启动时，每个线程都会检查是否有可用的对象，是否可以创建它，因为尚未达到最大值，否则它必须等待买一个。

这个想法是线程需要同步才能获取/创建引擎，但它们可以并行处理（ProcessWithEngine 方法）。处理过程可能需要几分钟，显然它正在按照我的意愿进行。

问题是，有时当 .notify() 被调用并且线程从 .wait() 中释放时，队列0 个项目，这应该是不可能的，因为就在 .notify() 之前，添加了一个项目。

可能是什么问题？

代码是这样的：

Queue _queue = new Queue();

int _poolMax = 4;
int _poolMin = 1;
int _poolCurrent =0;


public void Process(Object[] parameters) throws Exception
{
    Engine engine = null;

    synchronized(_queue) 
    {
        if(_queue.isEmpty() && _poolCurrent >= _poolMax)
        { 
            _queue.wait();

            // HERE : sometimes _queue.isEmpty() is true at this point.

            engine = (SpreadsheetEngine)_queue.dequeue();

        }
        else if (_queue.isEmpty() && _poolCurrent < _poolMax)
        {               
            engine = CreateEngine();
            _poolCurrent++;
        }
        else
        {               
            engine = (Engine)_queue.dequeue();
        }   
    }

    ProcessWithEngine(engine, parameters);


    // work done
    synchronized(_queue) 
    {
        _queue.enqueue(engine);

        _queue.notify();
    }
}

我已经修复了它这样做：

            do
            {
                _queue.wait();

            }
            while(_queue.isEmpty());

但基本上这意味着一个线程正在失去它的轮次，并且可能意味着稍后超时。

Answer 1

对 .wait() 的所有调用都必须包含在 while 循环中。调用 wait() 可以随机唤醒。

根据文档 ：“与单参数版本一样，中断和虚假唤醒是可能的，并且此方法应始终在循环中使用：”

Answer 2

使用您的解决方案，不是每个线程都进入无限的 wait() 吗？

正常的习惯用法是这样的：

synchronized(stuff) {
  while (mustWait) 
     wait();
  // do things with stuff
}

另一方面，既然您已经在使用队列，为什么不将其设为 java.util.concurrent.BlockingQueue 并免费获得并发解决方案呢？

Answer 3

至少有两个原因可能导致这种情况：

• 虚假唤醒，如 Justin Waugh 所指出的
• 另一个线程获取锁并在其间调用 dequeue() - 在第一个线程调用 notify() 之后> 并完成其 synchronized 块，但在第二个线程实际从其 wait() 中唤醒之前。这是可能的，因为 synchronized/wait()/notify() 不能保证公平性。

因此 wait() 应始终在循环内使用：

while (_queue.isEmpty())
    _queue.wait();