Java：在非阻塞队列上等待的CPU等待数已满

Question

I have the following code:

public void run() {
    while (true) {
        m = q.poll();
        if (m != null) {
            kf.sendMessage(m.topic, m.message);
        }
    }
}

where q is a ConcurrentLinkedQueue. Currently this is eating 100% of my CPU. Is there a more efficient way to wait on a non-blocking queue? I prefer to use a non-blocking queue because I am expecting bursty traffic from the producers on the queue, so I want to maximize performance. Is there a way to relinquish control of the cpu for my thread if q.poll() returns null?

I have the option of switching to a blocking queue, but I am curious what the proper way of doing this is.

Edit - Lots of good responses! Thanks for all your help. For now I'm going to just switch to a linkedblockqueue, and if I start running into performance issues re-evaluate.

Answer 1

If you have nothing else to do, and just want to wait (without using CPU) until data is available, then use a blocking queue. That's exactly what it's made for, with methods like take :

Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque), waiting if necessary until an element becomes available .

If you are interesting in how this is implemented, you can take a look at the source for these classes, for example LinkedBlockingQueue#take :

public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();
    try {
        while (count.get() == 0) {
            notEmpty.await();
        }
        x = dequeue();
        c = count.getAndDecrement();
        if (c > 1)
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        signalNotFull();
    return x;
}

As you can see, they maintain a couple of Conditions to signal if the queue is empty or not.

Answer 2

Since you're dealing with bursty behavior, you could wait when you've checked the queue and it's empty.

while (true) {
    m = q.poll();
    if (m != null) {
        kf.sendMessage(m.topic, m.message);
    } else {
        // Queue was empty, wait for a little while
        // Adjust time based on your requirements
        Thread.sleep(100);
    }
}

You should probably benchmark this to make sure it's actually faster than using a BlockingQueue though.

Answer 3

Consider to use BlockingQueue successors. In such case you do not need to iterate over empty list, thread waiting until next element in collection appears

---

public void run() {
    while (true) {
       m = q.take();
       kf.sendMessage(m.topic, m.message);
    }
}

Answer 4

If you have your heart set on a ConcurrentLinkedQueue , you can do something along the lines of:

public void run() {
  while (true) {
    m = q.poll();
    if (m != null) {
        kf.sendMessage(m.topic, m.message);
    } else Thread.yield();
  }
}

More about Thread.yield . Also consider sleeping for some small amount of time, say 50ms.