I want to use java.util.ConcurrentLinkedQueue as a non-durable queue for a Servlet. Here's the blurb from the javadoc for the class.
An unbounded thread-safe queue based on linked nodes. A ConcurrentLinkedQueue is an appropriate choice when many threads will share access to a common collection. This queue does not permit null elements.
Now imagine I have 1000 concurrent requests on the servlet, and each thread will need to enque an object into the ConcurrentLinkedQueue. From the description, should I conclude that it will have no problems handling the load ? The guarantee that I will need is that:
- I automatically receive the thread-safe guarantee without needing to do my own synchronization.
- I will not lose any requests if the traffic load goes beyond 1000 concurrent request.
You're essentially asking three different questions (two of them explicitly and one implicitly.) Here they are, with my answers:
1. Do I need to do my own synchronization if I use
Atomic operations on the concurrent collections are synchronized for you. In other words, each individual call to the queue is guaranteed thread-safe without any action on your part. What is not guaranteed thread-safe are any operations you perform on the collection that are non-atomic.
For example, this is threadsafe without any action on your part:
However; non-atomic calls to the queue are not automatically thread-safe. For example, the following operations are not automatically threadsafe:
That last one is not threadsafe, as it is very possible that between the time isEmpty is called and the time poll is called, other threads will have added or removed items from the queue. The threadsafe way to perform this is like this:
Again...atomic calls to the queue are automatically thread-safe. Non-atomic calls are not.
2. Am I guaranteed not to lose calls to
java.util.ConcurrentLinkedQueue if there are 1000 simultaneous requests?
Because this is an unbounded implementation you are guaranteed that no matter how many simultaneous requests to make, the queue will not lose those requests (because of the queue's concurrency...you might run out of memory or some such...but the queue implementation itself will not be your limiting factor.) In a web application, there are other opportunities to "lose" requests, but the synchronization (or lack thereof) of the queue won't be your cause.
3. Will the
java.util.ConcurrentLinkedQueue perform well enough?
Typically, we talk about "correctness" when we talk about concurrency. What I mean, is that Concurrent classes guarantee that they are thread-safe (or robust against dead-lock, starvation, etc.) When we talk about that, we aren't making any guarantees about performance (how fast calls to the collection are) - we are only guaranteeing that they are "correct."
However; the ConcurrentLinkedQueue is a "wait-free" implementation, so this is probably as performant as you can get. The only way to guarantee load performance of your servlet (including the use of the concurrent classes) is to test it under load.
Jared, I really liked your explanation. Thanks. – ashitaka Jan 13 '09 at 1:39
No problem - if this sufficiently answered your question, you might think about "Accepting" it (by clicking the checkmark to the left of the answer.) – Jared Jan 13 '09 at 15:56
If the consumer needs to block on poll, use a BlockingQueue, which has an atomic take() method that will block until the queue is not empty. – Adam Jaskiewicz Mar 5 '09 at 21:33
Synchronizing on the queue in this way won't do what you are trying to do. Other threads will still be able to poll/offer on the queue, even while you are in that block, unless you synchronize ALL access to the queue. Doing so would make using a ConcurrentLinkedQueue pretty pointless. – Adam Jaskiewicz Mar 5 '09 at 22:02
Good point, Adam. This answer will get re-written as soon as I squeeze in the time. – Jared Mar 5 '09 at 22:20