How to use ConcurrentLinkedQueue?

by

No, the methods don’t need to be synchronized, and you don’t need to define any methods; they are already in ConcurrentLinkedQueue, just use them. ConcurrentLinkedQueue does all the locking and other operations you need internally; your producer(s) adds data into the queue, and your consumers poll for it.

First, create your queue:

Queue<YourObject> queue = new ConcurrentLinkedQueue<YourObject>();

Now, wherever you are creating your producer/consumer objects, pass in the queue so they have somewhere to put their objects (you could use a setter for this, instead, but I prefer to do this kind of thing in a constructor):

YourProducer producer = new YourProducer(queue);

and:

YourConsumer consumer = new YourConsumer(queue);

and add stuff to it in your producer:

queue.offer(myObject);

and take stuff out in your consumer (if the queue is empty, poll() will return null, so check it):

YourObject myObject = queue.poll();

For more info see the Javadoc

EDIT:

If you need to block waiting for the queue to not be empty, you probably want to use a LinkedBlockingQueue, and use the take() method. However, LinkedBlockingQueue has a maximum capacity (defaults to Integer.MAX_VALUE, which is over two billion) and thus may or may not be appropriate depending on your circumstances.

If you only have one thread putting stuff into the queue, and another thread taking stuff out of the queue, ConcurrentLinkedQueue is probably overkill. It’s more for when you may have hundreds or even thousands of threads accessing the queue at the same time. Your needs will probably be met by using:

Queue<YourObject> queue = Collections.synchronizedList(new LinkedList<YourObject>());

A plus of this is that it locks on the instance (queue), so you can synchronize on queue to ensure atomicity of composite operations (as explained by Jared). You CANNOT do this with a ConcurrentLinkedQueue, as all operations are done WITHOUT locking on the instance (using java.util.concurrent.atomic variables). You will NOT need to do this if you want to block while the queue is empty, because poll() will simply return null while the queue is empty, and poll() is atomic. Check to see if poll() returns null. If it does, wait(), then try again. No need to lock.

Finally:

Honestly, I’d just use a LinkedBlockingQueue. It is still overkill for your application, but odds are it will work fine. If it isn’t performant enough (PROFILE!), you can always try something else, and it means you don’t have to deal with ANY synchronized stuff:

BlockingQueue<YourObject> queue = new LinkedBlockingQueue<YourObject>();

queue.put(myObject); // Blocks until queue isn't full.

YourObject myObject = queue.take(); // Blocks until queue isn't empty.

Everything else is the same. Put probably won’t block, because you aren’t likely to put two billion objects into the queue.

More Related Contents:

  1. Why must wait() always be in synchronized block
  2. How to share data with two(2) SwingWorker class in Java
  3. ConcurrentModificationException despite using synchronized
  4. Volatile vs Static in Java
  5. When would you call java’s thread.run() instead of thread.start()?
  6. Convert from List to CompletableFuture
  7. How do I simulate a buffered peripheral device with SwingWorker?
  8. Why there is no ConcurrentHashSet against ConcurrentHashMap
  9. How do I call some blocking method with a timeout in Java?
  10. Java Executors: how can I set task priority?
  11. What are the main uses of yield(), and how does it differ from join() and interrupt()?
  12. Volatile variable in Java
  13. What is the JVM thread scheduling algorithm?
  14. What is the difference between synchronized on lockObject and using this as the lock?
  15. Why does Thread.isInterrupted () always return false?
  16. Java Concurrency: CAS vs Locking [closed]
  17. How does `this` reference to an outer class escape through publishing inner class instance?
  18. Java memory model – can someone explain it?
  19. Are non-synchronised static methods thread safe if they don’t modify static class variables?
  20. When do I need to use AtomicBoolean in Java?
  21. Java concurrency: Countdown latch vs Cyclic barrier
  22. Hashmap concurrency issue
  23. Which concurrent Queue implementation should I use in Java?
  24. Java concurrency: is final field (initialized in constructor) thread-safe?
  25. Java: ExecutorService that blocks on submission after a certain queue size [duplicate]
  26. Jboss Java EE container and an ExecutorService
  27. Java: is there no AtomicFloat or AtomicDouble?
  28. Future task of ExecutorService not truly cancelling
  29. Multithreading Socket communication Client/Server
  30. Controlling Task execution order with ExecutorService

Leave a Comment