My thread pool has a fixed number of threads. These threads need to write and read from a shared list frequently.
So, which data structure (it better be a List, must be monitor-free) in java.util.concurrent package is best in this case?
This question is related to
java
concurrency
Any Java collection can be made to be Thread-safe like so:
List newList = Collections.synchronizedList(oldList);
Or to create a brand new thread-safe list:
List newList = Collections.synchronizedList(new ArrayList());
ConcurrentLinkedQueue uses a lock-free queue (based off the newer CAS instruction).
You might want to look at ConcurrentDoublyLinkedList written by Doug Lea based on Paul Martin's "A Practical Lock-Free Doubly-Linked List". It does not implement the java.util.List interface, but offers most methods you would use in a List.
According to the javadoc:
A concurrent linked-list implementation of a Deque (double-ended queue). Concurrent insertion, removal, and access operations execute safely across multiple threads. Iterators are weakly consistent, returning elements reflecting the state of the deque at some point at or since the creation of the iterator. They do not throw ConcurrentModificationException, and may proceed concurrently with other operations.
If set is sufficient, ConcurrentSkipListSet might be used. (Its implementation is based on ConcurrentSkipListMap which implements a skip list.)
The expected average time cost is log(n) for the contains, add, and remove operations; the size method is not a constant-time operation.
If the size of the list if fixed, then you can use an AtomicReferenceArray. This would allow you to perform indexed updates to a slot. You could write a List view if needed.
Source: Stackoverflow.com