EdTech

Concurrent Collection in Java

In Synchronized Collection a thread lock the entire list. Only one thread access the entire list at a time. In concurrent collection a threat lock one element, each element can be accessed by different thread concurrently

Java supported multithreading and concurrency from initiation. Java has introduced the concurrent collection in java 5.0 and java 6.0 over the synchronized collection to improve the performance in a multithreading environment. java has provided concurrent collection API apart from collection API to handle the multithreading and concurrency in a better manner. We can find all the new concurrent collection Interfaces and Classes under the package name java.util.concurrent.

In this article, we will focus on some Key interfaces and classes of the java.util.concurrent package.

Synchronized Collection v/s Concurrent Collection:

Synchronized Collection:

Synchronized Collections are slow in performance
Multiple threads can access a synchronized collection sequentially. Only one thread can access the collection at a time.
Synchronized Collection locks the entire collection.
Permits null values.
Static synchronized methods of Collections class are used to make a collection synchronize.

Concurrent Collection

Concurrent Collections are fast in performance
Multiple threads can access a concurrent collection concurrently. Multiple threads can access the collection at a time.
Concurrent Collection does not lock the entire collection, it does lock only one element at a time.
In other words, each element has a separate lock. It does not permit null values.

Concurrent Collection Key Interfaces:

Interface	Details
BlockinDeque	A Deque that additionally supports blocking operations that wait for the deque to become non-empty when retrieving an element, and wait for space to become available in the deque when storing an element.
BlockingQueue	A Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element.
ConcurrentMap	A Map providing thread safety and atomicity guarantees
ConcurrentNavigableMap	A ConcurrentMap supporting NavigableMap operations, and recursively so for its navigable sub-maps.
TransferQueue	A BlockingQueue in which producers may wait for consumers to receive elements.

Concurrent Collection's classes:

Classes	Description
ArrayBlockingQueue	A blocking queue class based on bounded Java Array. Once instantiated, cannot be resized.
SynchronousQueue	A blocking queue in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa.
LinkedBlockingQueue	An optionally-bounded blocking deque based on linked nodes.
LinkedBlockingDeque	An optionally-bounded blocking queue based on linked nodes.
LinkedTransferQueue	Implementation class of TransferQueue. An unbounded TransferQueue based on linked nodes.
PriorityBlockingQueue	An unbounded blocking queue that uses the same ordering rules as class PriorityQueue and supplies blocking retrieval operations.
ConcurrentHashMap	A hash table supporting full concurrency of retrievals and high expected concurrency for updates.
ConcurrentSkipListMap	A scalable concurrent ConcurrentNavigableMap implementation.

Example:

Synchronized HashMap Implementation

               
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class TestHashMap extends Thread {
private static Map hm = Collections.synchronizedMap(new HashMap());
	public void run() {
		hm.put("Four", 4);
	}
	public static void main(String[] args) {
		hm.put("One", 1);
		hm.put("Two", 2);
		hm.put("Three", 3);
		TestHashMap t1 = new TestHashMap();
		t1.start();
		for (Object o : hm.entrySet()) {
			System.out.println(o);
		}
		System.out.println(hm);
	}
}

ConcurrentHashMap Implementation:

              
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class TestHashMap extends Thread {
	private static ConcurrentHashMap hm = new ConcurrentHashMap();
	public void run() {
		hm.put("Four", 4);
	}
	public static void main(String[] args) {
		hm.put("One", 1);
		hm.put("Two", 2);
		hm.put("Three", 3);
		TestHashMap t1 = new TestHashMap();
		t1.start();
		for (Object o : hm.entrySet()) {
			System.out.println(o);
		}
		System.out.println(hm);
	}
}

About Us

Contact Us