Hvorfor er denne operation så dyr

Jeg har en server med et antal arbejder-tråde. Arbejderne aktiveres ved at lægge noget i deres "handoff-box" (en QueueArray-instans med 1 plads). Så længe der ikke er noget at lave, står arbejderen altså blokkeret i QueueArray.remove(), der er en synkroniseret metode, som anvender wait(), så længe køen er tom. QueueArray ses nedenfor.

I et server-scenarie står remove() der kalder waitWhileEmpty(), altså wait(), for over 60% af CPU-forbruget, altså over 60% af den tid, den aktuelle tråd faktisk er på CPU'en, hvordan i al verden kan det være !?

package com.shockwaved.octane.shared.util;

public class QueueArray {
  private Object[] queue;
  private int capacity;
  private int size;
  private int head;
  private int tail;

  public QueueArray(int cap) {
    capacity = (cap > 0) ? cap : 1;
    queue = new Object[capacity];
    head = 0;
    tail = 0;
    size = 0;
  }

  public int capacity() { return capacity; }

  public synchronized int size() { return size; }

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

  public synchronized boolean isFull() { return (size == capacity); }

  public synchronized void add(Object obj) throws InterruptedException {
    waitWhileFull();
    queue[head] = obj;
    head = (head + 1) % capacity;
    size++;
    notifyAll();
  }

  public synchronized Object remove() throws InterruptedException {
    waitWhileEmpty();
    Object obj = queue[tail];
    queue[tail] = null;
    tail = (tail + 1) % capacity;
    size--;
    notifyAll();
    return obj;
  }

  private synchronized void waitWhileEmpty() throws InterruptedException {
    while (isEmpty()) { wait(); }
  }

  private synchronized void waitWhileFull() throws InterruptedException {
    while (isFull()) { wait(); }
  }
}