Blog

java.util.concurrent package

The Java programming language has a popular built-in utility called java.util.concurrent, a Java package or library that provides Java developers with advanced features such as classes and interfaces for programming concepts like concurrency and multithreading.

These concepts were introduced in the Java language to make it easier for developers to create and develop programs where multiple thread tasks are running simultaneously within a single program environment.

Instead of manually managing thread tasks, thread locks, and task synchronization in an individual Java program, the java.util.concurrent Java package provides higher-level and secure concurrency utilities.

Why do developers need the java.util.concurrent utility in the Java language?

Suppose we manually create and manage multiple threads at the same time in a Java program.

Thread task tsk1 = new Thread(task1);

Thread task tsk2 = new Thread(task2);

Thread task tsk3 = new Thread(task3);

tsk1.start();

tsk2.start();

tsk3.start();

For large Java application development, manually managing multiple thread tasks can be a bit complex. Therefore, Java provides developers with the following tools in the java.util.concurrent package.

• It creates a thread pool
• Provides thread task lock features
• Provides multiple thread synchronization utilities
• Provides concurrent collection features
• Supports atomic variable declaration
• Provides Task and Future features
• Semaphore concepts
• Blocking queue availability features

All of these features make concurrent programming in Java easier and more reliable.

Let explore Important Classes and Interfaces of java thread class

Java.util.concurrent has some essential components or features to simplify the concept of thread tasks in Java.

ExecutorService with the java.util.concurrent class.

ExecutorService is used in a Java program to manage and control a pool of thread tasks.

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class Main {

public static void main(String[] args) {

ExecutorService executor =

Executors.newFixedThreadPool(3);

executor.execute(() -> {

System.out.println(“User Define Thread Task 1”);

});

executor.execute(() -> {

System.out.println(“User Define Thread Task 2”);

});

executor.execute(() -> {

System.out.println(“User Define Thread Task 3”);

});

executor.shutdown();

}

}

In this example, instead of manually creating separate thread tasks, the Thread Task Executor manages a worker thread for the Java user.

Callable and Future with the java.util.concurrent class.

In a Java thread, a Runnable can perform a task, but it does not return a result.

Similarly, a Callable can return a value.

Example of Callable and Future.

import java.util.concurrent.*;

public class Main {

public static void main(String[] args) {

ExecutorService executor =

Executors.newSingleThreadExecutor();

Callable<Integer> task = () -> {

return 625 / 25;

};

Future<Integer> output = executor.submit(task);

try {

System.out.println(output.get());

} catch (InterruptedException | ExecutionException ex) {

ex.printStackTrace();

}

executor.shutdown();

}

}

Here in this example output.

25

Here in the above example.

Callable<Integer>

This displays a thread task in the current program, which returns an Integer value.

The Future statement displays the output result that will be obtained after the thread task completes.

Locks are used with the java.util.concurrent class.

In a Java thread task program, the package provides a Lock interface and important classes like ReentrantLock.

Example of a thread lock task.

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

class Tester {

private int count_value = 0;

private final Lock lock = new ReentrantLock();

void increase() {

lock.lock();

try {

count_value++;

} finally {

lock.unlock();

}

}

}

In this example, this thread lock ensures that the critical task section is protected from simultaneous access by multiple threads.

Why use locks in a Java thread task?

In lieu of thread-task synchronization, explicit locks provide some more advanced features, such as.

• Explicit lock/unlock operation features
• TryLock() features
• Interruptible lock acquisition features
• More flexible locking strategy features

Atomic classes with the java.util.concurrent class.

This package provides Java developers with atomic classes, such as:

• AtomicInteger
• AtomicLong
• AtomicBoolean

These provide thread-safe atomic operations without requiring traditional synchronization for each Java thread task operation.

Example of Atomic classes.

import java.util.concurrent.atomic.AtomicInteger;

class Tester {

AtomicInteger count_value = new AtomicInteger(0);

void increase() {

count_value.increaseAndGet();

}

}

In this example, increaseAndGet() atomically increments a value.

Semaphore with the java.util.concurrent class.

A semaphore in a Java thread task controls access to a thread task resource by using multiple permissions.

For example, suppose we want only three thread tasks to access a resource at a time in a Java program.

import java.util.concurrent.Semaphore;

Semaphore semaphore = new Semaphore(3);

In this, a thread task can acquire a resource.

semaphore.acquire();

And release it when needed.

semaphore.release();

Based on the above concept.

System Thread Task Resource

                               |

          ┌──────┼─────┐

          ↓                 ↓                ↓

Thread Task Thread Task Thread Task

     1                    2                 3

Here, max = 3 thread tasks are defined.

CountDownLatch with the java.util.concurrent class.

This class, CountDownLatch, allows one or more thread tasks in a Java-created thread to wait until a certain number of operations have been completed.

CountDownLatch Java Thread Example.

import java.util.concurrent.CountDownLatch;

CountDownLatch latch = new CountDownLatch(3);

It calls the current thread task on each completed task.

latch.countDown();

Under this condition, other thread tasks can wait on it.

latch.await();

When the count value reaches zero, the waiting thread continues.

Example of the CountDownLatch Java Thread concept.

Thread Task 1 → countDown()

Thread Task 2 → countDown()

Thread Task 3 → countDown()

↓

When the count value reaches 0

↓

The thread waiting on it continues in the task process.

CyclicBarrier with the java.util.concurrent class.

Here, in a Java program, a CyclicBarrier helps multiple threads wait on each other at a common synchronization point.

CyclicBarrier barrier =

new CyclicBarrier(3);

This is called by each thread in the task process.

barrier.await();

When all three threads finally reach the barrier, they can continue.

Thread Task 1 ──────┐

Thread Task 2 ──────┼──→ Thread’s barrier point → Continue the thread

Thread Task 3 ──────┘

Blocking queue with the java.util.concurrent class.

A blocking queue in Java thread tasks is more useful for producer-consumer problems.

Where a system task producer inserts items into the queue.

queue.put(item);

A consumer takes items as needed.

queue.take();

If the item queue is empty, the take() function can make the thread task wait until an item becomes available.

Example of a blocking queue.

import java.util.concurrent.*;

BlockingQueue<Integer> queue =

new ArrayBlockingQueue<>(10);

Blocking queues in Java are commonly used when one group of thread tasks creates data, while another group processes it as needed.

ConcurrentHashMap with the java.util.concurrent class.

In Java, ConcurrentHashMap provides a thread-safe implementation of a map designed for simultaneous access across thread tasks.

import java.util.concurrent.ConcurrentHashMap;

ConcurrentHashMap<Integer, String> map =

new ConcurrentHashMap<>();

map.put(1, “Java task”);

map.put(2, “Java Thread”);

This feature is used in Thread Tasks when multiple threads need to access and update the map simultaneously.

A look at the main components of the Java Thread java.util.concurrent class.

java.util.concurrent

|

+– ExecutorService

| └── Thread Pool Methods

|

+– ScheduledExecutorService

| └── Delayed/Periodic Thread Task Management

|

+– Callable / Future

| └── Asynchronous Thread Task Results

|

+– Lock / ReentrantLock

| └── Clear Thread Task Synchronization Concept

|

+– AtomicInteger

| └── Atomic Operations on Thread Tasks

|

+– Semaphore

| └── Limit simultaneous access to multiple thread tasks

|

+– CountDownLatch

| └── Wait for multiple thread tasks

|

+– CyclicBarrier

| └── Synchronize simultaneous access to multiple thread tasks

|

+– BlockingQueue

| └── Producer-consumer thread tasks for user

|

+– ConcurrentHashMap

└── Map access to concurrent Java thread tasks

Benefits of the java.util.concurrentThreadTask.

• Simplifies multithreading – This feature provides Java developers with pre-built concurrency utilities, the ThreadTask class, instead of requiring them to create everything themselves.
• Improved thread management – This allows threads to be reused in a pool instead of creating a new thread for each task.
• Thread safety – Built-in classes for Java ThreadTasks, such as ConcurrentHashMap and AtomicInteger, provide mechanisms designed to manage simultaneous access to thread tasks.
• Improved performance – Proper use of pools and simultaneous data structures in Java ThreadTasks can reduce unnecessary thread creation and synchronization overhead in task processing.
• Provides advanced synchronization – Other popular Java ThreadTask classes, such as Semaphore, CountDownLatch, and CyclicBarrier, provide synchronization mechanisms beyond basic synchronization.

Conclusion of the java.util.concurrent package.

The java.util.concurrent package is a Java package or library that provides several built-in classes and interfaces for concurrent and multithreaded task programming. This class package library simplifies Java thread task management, task execution, task process synchronization, and communication between multiple threads. Important thread task class library package components include ExecutorService, ScheduledExecutorService, Callable, Future, Lock, Semaphore, CountDownLatch, CyclicBarrier, BlockingQueue, AtomicClass, and ConcurrentHashMap.

An easy way to remember a thread task in Java.

The java.util.concurrent package is an important toolkit for advanced Java features for multithreading tasks and concurrency.