Concurrent Collections in Java

Java offers a number of data systems that allow the developers to work with collections of records effectively. When more than one threads are involved, concurrent collections come to be essential to make sure data integrity and thread safety. In this section, we will discover concurrent collections in Java and offer code examples to demonstrate their use.

Concurrency in Java

Concurrency in Java refers to the execution of a couple of threads concurrently. When multiple threads access and modify shared records systems, troubles like race situations and data corruption can occur. To cope with those troubles, Java offers a hard and fast of concurrent collections within the java.util.concurrent package deal.

1. ConcurrentHashMap:

A ConcurrentHashMap is a thread-steady implementation of a Map interface. It permits a couple of threads to have a look at and write without blocking off each other. Here's an example:

ConcurrentMapExample.java

import java.util.concurrent.ConcurrentHashMap;
public class ConcurrentMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
        concurrentMap.put("one", 1);
        concurrentMap.put("two", 2);
        concurrentMap.put("three", 3);
        int value = concurrentMap.get("two");
        System.out.println("Value for key 'two': " + value);
    }
}

Output:

Value for key 'two': 2

2. CopyOnWriteArrayList:

CopyOnWriteArrayList is a thread-stable listing wherein adjustments create a modern day duplicate of the underlying array. It ensures that the actual list stays unaltered in some unspecified time in the future of generation via other threads. Here's an instance:

CopyOnWriteArrayListExample.java

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
public class CopyOnWriteArrayListExample {
    public static void main(String[] args) {
        List<Integer> list = new CopyOnWriteArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        for (Integer num : list) {
            System.out.println(num);
        }
    }
}

Output:

1
2
3

3. BlockingQueue:

BlockingQueue is a concurrent queue that is able to make blocking off operations for getting added and doing away with factors. It is generally implemented for producer-consumer cases. Let's see an example for the usage of LinkedBlockingQueue:

BlockingQueueExample.java

import java.util.concurrent.LinkedBlockingQueue;
public class BlockingQueueExample {
    public static void main(String[] args) {
        LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
        new Thread(() -> {
            try {
                queue.put(1);
                queue.put(2);
                queue.put(3);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
        try {
            System.out.println("Removed from queue: " + queue.take());
            System.out.println("Removed from queue: " + queue.take());
            System.out.println("Removed from queue: " + queue.take());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

Output:

Removed from queue: 1
Removed from queue: 2
Removed from queue: 3

4. ConcurrentLinkedQueue:

ConcurrentLinkedQueue is a non-blocking off thread-safe queue. It's an inexperienced choice for plenty producer-consumer situations.

ConcurrentQueueExample.java

import java.util.concurrent.ConcurrentLinkedQueue;
public class ConcurrentQueueExample {
    public static void main(String[] args) {
        ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        for (Integer num : queue) {
            System.out.println(num);
        }
    }
}

Output:

1
2
3

5. ConcurrentSkipListSet:

ConcurrentSkipListSet is a thread-secure implementation of a SortedSet the use of a skip list. It allows elements to be saved in a taken care of order and helps concurrent get entry to.

SkipListSetExample.java

import java.util.NavigableSet;
import java.util.concurrent.ConcurrentSkipListSet;
public class SkipListSetExample {
    public static void main(String[] args) {
        NavigableSet<Integer> set = new ConcurrentSkipListSet<>();
        set.add(3);
        set.add(1);
        set.add(2);
        for (Integer num : set) {
            System.out.println(num);
        }
    }
}

Output:

1
2
3

6. LinkedBlockingQueue:

BlockingQueueExample.java

import java.util.concurrent.LinkedBlockingQueue;
public class BlockingQueueExample {
    public static void main(String[] args) {
        TheLinkedBlockingQueue<Integer> queue = new TheLinkedBlockingQueue<>(2);
        new Thread(() -> {
            try {
                queue.put(1);
                queue.put(2);
                queue.put(3); 
            } catch (TheInterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
        try {
            System.out.println("Delete from queue: " + queue.take());
            System.out.println("Delete from queue: " + queue.take());
            System.out.println("Delete from queue: " + queue.take());
        } catch (TheInterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

Output:

Delete from queue: 1
Delete from queue: 2

In Conclusion, Concurrent collections in Java are important equipment for writing multi-threaded packages that require shared information systems. They ensure thread safety and help prevent not unusual concurrency troubles. In this article, we explored some of the fundamental concurrent collections in Java, and we supplied code examples to demonstrate their use.

By using those collections, you may write stable concurrent programs in Java. Java gives a variety of data structures that permit developers to artwork with collections of records efficaciously. concurrent collections end up crucial to make sure information integrity and thread safety.

Next TopicCreate JSON Node in Java

← prev next →