Java Concurrent Package:
In Java multithreading is a new doorway for numerous possibilities. But it
can be complex for programmer to be implemented from the beginning
and here “Java Concurrency Package” comes in the picture. With the help
of Java Concurrency Package we can use concurrency, multithreading
and parallelism on Java platform. The backbone of Java concurrency is
threads. This package has a set of classes and interfaces that helps in
developing concurrent applications in Java without any hassle.
Main Components of Concurrent Package:
1. Executor: The Executor interface provides a simple mechanism for
executing tasks without directly managing threads. It decouples task
submission from task execution, allowing applications to specify
what should run without worrying about how it runs. Implementations
decide whether tasks run in new threads, pooled threads, or the
calling thread.
Example:
Executor executor =
[Link]();
[Link](() -> [Link]("Task
executed"));
2. ExecutorService: ExecutorService extends Executor and
represents a complete framework for managing thread pools. It
provides methods for submitting tasks, tracking their progress, and
shutting down the executor. It supports both Runnable and Callable
tasks and can return Future objects for result retrieval.
Example:
ExecutorService service =
[Link](2);
[Link](() -> [Link]("Running
task"));
[Link]();
3. ScheduledExecutorService:
The ScheduledExecutorService interface supports task execution
after a delay or at periodic intervals. It serves as a high-level
replacement for Timer and TimerTask with improved flexibility and
thread-pool usage. It is commonly used for repeated background
maintenance tasks.
Example:
ScheduledExecutorService scheduler =
[Link](1);
[Link](() -> [Link]("Runs after
3 seconds"),
3, [Link]);
4. Future:
A Future represents the result of an asynchronous computation.
It provides methods to check whether computation is complete, wait
for its completion, and retrieve the result. Attempting to get the result
before completion blocks the calling thread.
Example:
ExecutorServiceservice =
[Link]();
Future<Integer> future = [Link](() -> 42);
[Link]([Link]());
[Link]();
5. CountDownLatch:
CountDownLatch allows one or more threads to wait until a set of
operations being performed by other threads completes.
It maintains a counter that is decremented by calls to countDown().
Threads calling await() block until the counter reaches zero.
Example:
CountDownLatch latch = new CountDownLatch(3);
for (int i = 0; i < 3; i++)
new Thread(() -> [Link]()).start();
[Link]();
[Link]("All tasks finished!");
6. CyclicBarrier:
CyclicBarrier enables multiple threads to wait for each other at a
predefined synchronization point. When all participating threads
reach the barrier, it is released and can be reused for subsequent
cycles. An optional barrier action can run once per cycle when the
barrier is tripped.
Example:
CyclicBarrier barrier = new CyclicBarrier(3,
() -> [Link]("Barrier reached")
);
for (int i = 0; i < 3; i++)
new Thread(() -> {
try { [Link](); } catch (Exception
ignored) {}
}).start();
7. Semaphore:
A Semaphore controls access to a shared resource by permitting
only a specified number of threads to access it at the same time.
Threads acquire a permit before proceeding and release it when
finished. Semaphores can be used for resource-pool management
or limiting concurrent access.
Example:
Semaphore sem = new Semaphore(2);
[Link]();
[Link]("Accessing resource");
[Link]();
8. ThreadFactory:
ThreadFactory is used to create new threads in a controlled and
consistent manner. It allows customization of thread attributes such
as names, priorities, and daemon status. Thread pools use thread
factories to standardize thread creation.
Example:
ThreadFactory factory = r -> {
Thread t = new Thread(r);
[Link]("Worker-Thread");
return t;
};
[Link](() ->
[Link]("Hello")).start();
9. BlockingQueue:
A BlockingQueue is a thread-safe queue that blocks producers when
the queue is full and blocks consumers when the queue is empty.
It simplifies producer-consumer designs by eliminating the need for
manual synchronization. Different implementations support various
behaviors (bounded, unbounded, priority-based).
Example:
BlockingQueue<String> queue = new
ArrayBlockingQueue<>(1);
new Thread(() -> {
try { [Link]("Item"); } catch (Exception
ignored) {}
}).start();
new Thread(() -> {
try { [Link]([Link]()); } catch
(Exception ignored) {}
}).start();
10. DelayQueue:
A DelayQueue is a specialized queue in which elements become
available only after their associated delay has expired. It is commonly
used for time-based scheduling tasks such as retries, expirations, or
timed releases. Only delayed elements whose time has elapsed can
be retrieved.
Example:
class DelayedItem implements Delayed {
long end = [Link]() + 3000;
public long getDelay(TimeUnit unit) {
return [Link](end -
[Link](), [Link]);
}
public int compareTo(Delayed d) { return 0; }
}
DelayQueue<DelayedItem> dq = new DelayQueue<>();
[Link](new DelayedItem());
[Link](); // Available after delay
11. Lock:
Lock provides more extensive locking operations than the built-in
synchronized keyword. It allows explicit lock control, timed attempts,
and interruptible acquisition. It offers improved flexibility for complex
synchronization scenarios.
Example:
Lock lock = new ReentrantLock();
[Link]();
try {
[Link]("Critical section");
} finally {
[Link]();
}
12. Phaser:
A Phaser is a flexible synchronization barrier supporting dynamic
registration of threads. It allows coordination across multiple phases,
where each phase can have a different number of participating
parties. It generalizes both CountDownLatch and CyclicBarrier for
multi-step parallel workflows.
Example:
Phaser phaser = new Phaser(3);
for (int i = 0; i < 3; i++)
new Thread(() -> {
[Link]("Phase 1");
[Link]();
[Link]("Phase 2");
[Link]();
}).start();