Concurrent Collections and Maps-OCP Oracle Certified Professional

Concurrent Collections and Maps-OCP Oracle Certified Professional

Concurrent Collections and Maps 2 – Concurrency: Part II

Some collections allow the null value, and others do not. All concurrent collections, blocking queues, and concurrent maps do not allow the null value as elements, whereas the copy-on-write collections do. All collections that embody the concept of a set do not allow duplicates—for example, a CopyOnWriteArraySet. All maps (e.g., a ConcurrentHashMap) do not allow
Continue Reading

Concurrent Collections and Maps – Concurrency: Part II

23.7 Concurrent Collections and Maps Most of the collections in the java.util package are not thread-safe—executing concurrent operations on them is courting disaster. Exceptions to this are the legacy Vector and Hashtable classes, but these use a single lock, allowing only one thread at a time to execute an operation on the collection while other
Continue Reading

Concurrent Collections – Concurrency: Part II

Concurrent Collections Concurrent sets, queues, and deques are implemented by the classes Concurrent-SkipListSet, ConcurrentLinkedQueue, and ConcurrentLinkedDeque, respectively. These thread-safe classes implement the corresponding NavigableSet, Queue, and Deque interfaces in the java.util package, as shown in Figure 23.4 and summarized in Table 23.5. Their characteristics are summarized in Table 23.6. These concurrent collections are unbounded and
Continue Reading

The ConcurrentLinkedQueue Class – Concurrency: Part II

The ConcurrentLinkedQueue<E> Class The ConcurrentLinkedQueue class implements the Queue interface, as shown in Figure 23.6. No new methods are defined, and existing methods of the Queue interface (§15.6, p. 814) are implemented as shown in Table 23.7. Note that since it is an unbounded queue, the insert operations will always succeed. The ConcurrentLinkedDeque<E> Class The
Continue Reading

Concurrent Maps – Concurrency: Part II

Concurrent Maps Figure 23.5 shows the inheritance hierarchy of concurrent maps in the java.util .concurrent package. Note the interfaces ConcurrentMap<K,V> and ConcurrentNavigableMap<K,V> that extend the thread-unsafe map interfaces in the java.util package. Their implementations, ConcurrentHashMap<K,V> and ConcurrentSkipListMap<K,V>, provide efficient unsorted and sorted concurrent maps, respectively. The concrete map implementations are summarized in Table 23.9, together
Continue Reading

The ConcurrentNavigableMap Interface – Concurrency: Part II

The ConcurrentNavigableMap<K,V> Interface A concurrent, sorted map is defined by the ConcurrentNavigableMap<K,V> interface that extends both the ConcurrentMap<K,V> and the NavigableMap<K,V> interfaces. It overrides the methods shown below from its superinterfaces. Details on these overridden methods can be found in the ConcurrentMap<K,V> interface (p. 1491) and in the NavigableMap<K,V> interface (§15.10, p. 845). The ConcurrentSkipListMap<K,V>
Continue Reading

Blocking Queues – Concurrency: Part II

Blocking Queues Queues (and deques) are the indisputable choice when choosing a collection to manage shared data in producer-consumer problems. The interfaces for thread-unsafe queues (Queue, Deque) in the java.util package have been enhanced in the java.util.concurrent package to provide a wide variety of blocking queues that are thread-safe (Figure 23.6). These thread-safe queues are
Continue Reading

The BlockingQueue Interface – Concurrency: Part II

The BlockingQueue<E> Interface The java.util.concurrent.BlockingQueue interface extends the java.util.Queue interface, as shown in Figure 23.6. Compared to the operations shown for the Queue interface in Table 23.7, the BlockingQueue interface provides new insert and remove operations that can block or can time out—shown in the two rightmost columns in Table 23.13. Classes that implement the
Continue Reading

The BlockingDeque Interface – Concurrency: Part II

The BlockingDeque<E> Interface The java.util.concurrent.BlockingDeque interface extends both the java.util.Deque interface and the BlockingQueue interface, as shown in Figure 23.6. Compared to the operations shown for the ConcurrentLinkedDeque interface in Table 23.8, the Blocking-Deque interface provides new insert and remove operations, both at the head and tail of a deque, that can block or can
Continue Reading

Copy-on-Write Collections – Concurrency: Part II

Copy-on-Write Collections The copy-on-write collections comprise special-purpose concurrent lists and sets that are recommended when read operations vastly outnumber mutative operations on the collection. The classes CopyOnWriteArrayList and CopyOnWriteArraySet implement the List and the Set interfaces in the java.util package (Figure 23.7). A summary of the copy-on-write classes in the java.util.concurrent package is given in
Continue Reading