Definition of Java Concurrency Utilities
Java concurrency utility packages provide the powerful framework used in threaded utilities such as blocking queues or thread pools. Those packages free the programmer to craft that utility to use in hand. Java concurrency utility packages cover multi-threading, parallelism, and concurrency. Java concurrency is the ability that contains to run multiple programs in parallel. The backbone of concurrency in java is the thread.
Overview of Java Concurrency Utilities
Before adding the utility package to our code, first, we need to program our utility class ourselves. As we know, java is a multi-threaded programming language so we can develop the multithreaded program.
It will contain two or multiple parts that run concurrently, and it will handle different types of tasks, so at the same time, it will make the optimal resources use. Concurrency utilities in java offer multiple advantages. Java concurrency is easy to use, while the developer standard classes ourselves.
Key Takeaways
- The implementation of java concurrency utilities is reviewed and developed by performance and the experts of concurrency, this implementation is scalable and faster.
- To develop the concurrent classes, the difficult java language provides the primitives of low concurrency. We can use multiple concurrent packages in java.
Java.util.concurrent Package
The java util concurrent package provides a tool for the concurrent application.
Below are the packages and main components of java util concurrent packages:
1. Executor
The executor is an interface that represents the object provided from executed tasks. This depends on the particular implementation. The below example shows the executor package as follows.
Code:
import java.util.concurrent.Executor;
public class concurrent {
public void execute() {
Executor exec = (Executor) new concurrent();
exec.execute ( () -> {
});
}
}2. ExecutorService
This is a complete service used to process the threads. It manages the memory queue and it can schedule the task which was submitted. The below example shows ExecutorService as follows.
Code:
public class concurrent implements Runnable {
@Override
public void run() {
ExecutorService executor = Executors.newFixedThreadPool(10);
}
}3. ScheduledExecutorService
This is similar to the executor service, but it will perform the task as per schedule. The Executor and ExecutorService method perform their task without any delay.
Code:
public class concurrent implements Runnable {
@Override
public void run() {
ScheduledExecutorService exc
= Executors.newSingleThreadScheduledExecutor();
}
}4. Future
This method is used to represent the result of an anonymous operation. It will come with asynchronous operations. The example below shows how we can create the future instance as follows.
Code:
public class concurrent implements Runnable {
@Override
public void run() {
ExecutorService executorService = Executors.newFixedThreadPool(10);
Future<String> future = executorService.submit (() -> {
Thread.sleep(1000);
return "java concurrency";
});
}
}5. CountDownLatch
It is a utility class that blocks multiple threads until operations are completed. This method is initialized to use a counter, containing the integer type. The counter is decremented as per execution of the dependent thread is completed. While the counter is decremented to zero, another program thread is released.
Package
Below are the packages of java util concurrent packages. All the packages are important in java.
1. CyclicBarrier
This works the same as CountDownLatch, but the difference is that we can reuse it. It allows multiple threads to use await() method. The below example shows CyclicBarrier as follows.
Code:
public class concurrent implements Runnable {
private CB barrier;
public concurrent(CB ba) {
this.barrier = ba;
}
@Override
public void run() {
try {
LOG.info(Thread.currentThread().getName() +
" wait");
barrier.wait();
LOG.info(Thread.currentThread().getName() +
" released");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}2. Semaphore
This is used to block access to physical and logical resources. It contains the set of permits. When thread is entered into the semaphore, it is permitted whether it will permit or not. The below example shows semaphore as follows.
Code:
public class concurrent implements Runnable {
static Semaphore sm = new Semaphore(10);
public void execute() throws InterruptedException {
LOG.info("permit : " + sm.availablePermits ());
LOG.info("wait: " + sm.getQueueLength());
if (sm.tryAcquire ()) {
try {
}
finally {
sm.release();
}
}
}3. ThreadFactory
This acts as a pool of threads that creates a new thread as per demand. This will eliminate lots of code. The below example shows ThreadFactory as follows.
Code:
public class concurrent implements ThreadFactory {
private int tid;
private String stud_name;
public concurrent(String stud_name) {
tid = 1;
this.stud_name = stud_name;
}
@Override
public Thread newThread (Runnable r) {
Thread t = new Thread(r, stud_name, "-Thread_" + tid);
LOG.info("Created : " + tid + "and name : " + t.getName());
tid++;
return t;
}
}4. BlockingQueue
It supports flow control to introduce whether the queue is empty or full. To type the thread for enqueue is blocked until another thread makes space for the queue. It will block the thread until it will delete from the queue.
5. DelayQueue
This is the specialized queue that orders the elements as per delay time. The head of DelayQueue contains the element that was expired, and it will return a null value.
6. Lock
This is a utility used to block the other threads from accessing the segment of code. The lock and unlock are both separate methods.
7. Phaser
It is more flexible as compared with CountDownLatch and CyclicBarrier. It is used to act as a reusable barrier.
Java ConcurrentNavigableMap
This is a member of the java collection framework. It will extend from the interface of ConcurrentMap and NavigationMap. This provides thread-safe access to the elements of the map along with the method of navigation.
The below example shows ConcurrentNavigableMap as follows:
Code:
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;
public class concurrent
{
public static void main(String[] args)
{
ConcurrentNavigableMap<Integer, String> cn
= new ConcurrentSkipListMap <Integer, String>();
cn.put (1, "One");
cn.put (2, "Two");
cn.put (3, "Three");
cn.put (4, "Four");
System.out.println ("Mappings: "+ cn);
System.out.println ("HeadMap (3): "
+ cn.headMap (3));
System.out.println ("TailMap (3): "
+ cn.tailMap (3));
System.out.println ("SubMap (1, 3): "
+ cn.subMap (1, 3));
}
}Output:
Conclusion – Java Concurrency Utilities
It will contain two or multiple parts that run concurrently, and it will handle different types of tasks, so at the same time it will make the optimal resources use. Concurrency utilities in java offer multiple advantages. Those packages free the programmer to craft that utility. Java concurrency utility packages cover multi-threading, parallelism, and concurrency.
Recommended Articles
This is a guide to Java Concurrency Utilities. Here we discuss the introduction, Java.util.concurrent package and Java ConcurrentNavigableMap. You can also look at the following articles to learn more –
