Java Concurrency Utilities

Java Concurrency Utilities


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:

Java Concurrency Utilities

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 –

  1. Java Projects Resume
  2. Java Garbage Collectors Types
  3. Java Projects for Final Year
  4. Java HTTP Client

The post Java Concurrency Utilities appeared first on EDUCBA.



Full Courses

source