Modern Concurrency Utilities in Java (java.util.concurrent)

-

Traditional multithreading in Java using Thread, Runnable, synchronized, and wait/notify works, but it becomes difficult to scale in modern backend applications. Java introduced the java.util.concurrent package to simplify concurrency, improve performance, and avoid common threading issues.

1. Why java.util.concurrent?

Older threading models had several limitations:

  • Manual thread creation → expensive & slow
  • Risk of race conditions
  • Complex synchronization
  • No proper thread lifecycle management

The concurrency framework solves these problems using:

  • Thread pools
  • Locks
  • Atomic variables
  • Coordination tools
  • Asynchronous computation

2. ExecutorService (Thread Pooling)

ExecutorService manages threads efficiently and avoids creating too many threads.

ExecutorService service = Executors.newFixedThreadPool(5);
service.submit(() -> System.out.println("Task executed"));

Types of Executor Services:

  • newSingleThreadExecutor() – only one worker thread
  • newFixedThreadPool(n) – fixed-size thread pool
  • newCachedThreadPool() – creates threads as needed
  • newScheduledThreadPool(n) – supports scheduled tasks

3. Callable and Future (returning values)

Runnable cannot return results, but Callable can.

Callable task = () -> 5 + 10;
Future result = service.submit(task);
System.out.println(result.get());

Future allows you to:

  • Retrieve result using get()
  • Check if task is done
  • Cancel tasks

4. CompletableFuture (Modern Async Programming)

CompletableFuture enables asynchronous pipelines, non-blocking tasks, and combining results. 

CompletableFuture.supplyAsync(() -> fetchData())
    .thenApply(data -> transform(data))
    .thenAccept(out -> save(out));

5. CountDownLatch

Used when one or more threads must wait until a set of operations complete. 

CountDownLatch latch = new CountDownLatch(3);
latch.await(); // waits until count reaches 0

6. CyclicBarrier

All threads wait for each other and then proceed together.

CyclicBarrier barrier = new CyclicBarrier(3);
barrier.await();

7. Semaphore

Controls how many threads can access a resource at the same time.

Semaphore sem = new Semaphore(2);
sem.acquire();
// critical section
sem.release();

8. ReentrantLock (Advanced Locking)

More powerful than synchronized. Supports:

  • tryLock()
  • Fair locking
  • Interruptible locking
Lock lock = new ReentrantLock();
lock.lock();
try {
    // critical section
} finally {
    lock.unlock();
}

9. Atomic Variables

Atomic classes provide thread-safe operations without explicit locking.

AtomicInteger count = new AtomicInteger();
count.incrementAndGet();

10. Memory Visibility & volatile

volatile ensures updated values are visible across threads but does not provide atomicity. 

volatile boolean running = true;

11. Fork/Join Framework

Used for parallel computations using divide-and-conquer. 

ForkJoinPool pool = new ForkJoinPool();
pool.invoke(new MyRecursiveTask());

12. Thread-safe Collections

  • ConcurrentHashMap
  • CopyOnWriteArrayList
  • ConcurrentLinkedQueue
  • BlockingQueue

13. Real-World Scenarios

  • Producer-Consumer using BlockingQueue
  • Reader-Writer using ReadWriteLock
  • Async APIs using CompletableFuture
  • Parallel processing using Fork/Join

14. Best Practices

  • Always shutdown ExecutorService
  • Use thread pools instead of manual threads
  • Avoid shared mutable state
  • Prefer immutability
  • Use atomic variables for counters
  • Use synchronized only when needed

15. Debugging & Profiling Threads

Recommended tools:

  • Thread dumps (jstack)
  • VisualVM
  • IntelliJ Profiler
  • JConsole

These tools help identify deadlocks, long-running threads, CPU spikes, and thread leaks.

Conclusion

Modern concurrency tools in Java make multi-threaded programming faster, cleaner, and safer. Features like ExecutorService, CompletableFuture, CountDownLatch, and atomic variables are essential for building scalable, high-performance applications.

Comments

Post a Comment

Popular posts from this blog

Spring Boot on AWS EC2: Upload to S3 Securely Using IAM Role

-
When running a Spring Boot application on AWS EC2 , the most common security mistake is hardcoding AWS access keys inside application.properties . This is unnecessary and risky. AWS already provides a secure mechanism: IAM Roles attached to EC2 . In this blog, you will learn how to upload and download files to Amazon S3 from Spring Boot running on EC2 without any access keys , using: Spring Profiles AWS SDK v2 Instance Metadata Service (IMDS) IAM Roles Why Access Keys Are a Bad Idea on EC2 Typical S3 setups use: Access key Secret key Region Bucket This works only for local development. It should NOT be used on EC2. Problems with access keys: Stored in config or code (high risk) Might leak through Git, logs, or screenshots Require manual rotation Not needed if app runs on EC2 AWS automatically manages temporary credentials using the EC2 Instance Profile (IAM Role) . Architecture: EC2 → IAM Role → S3 Spring Boot app r...
Read more

Java Streams Intermediate Operations Explained with Examples

-
Image
The Java Stream API lets you process collections in a fluent, declarative style. In this post, we’ll walk through the most useful intermediate operations with simple examples. Note: Examples below use Java 8 compatible collect(Collectors.toList()) . If you’re on Java 16+, you can replace it with toList() . 1) filter() — Select elements by a condition Keeps only elements that match the predicate. List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10); List<Integer> res = list.stream() .filter(num -> num % 2 != 0) // keep only odd numbers .collect(Collectors.toList()); System.out.println(res); // [1, 3, 5, 7, 9] 2) map() — Transform each element Applies a function to every element and returns a stream of results. List<String> strs = Arrays.asList("rama", "anjaneya", "krishna"); List<String> upper = strs.stream() .map(String::toUpperCase) .collect(Collectors.toList()); System.o...
Read more

ConcurrentHashMap vs Synchronized HashMap in Java

-
Image
Introduction In multi-threaded Java applications, managing shared data safely and efficiently is crucial. Two common approaches are using Synchronized HashMap (via Collections.synchronizedMap(...) ) and ConcurrentHashMap . While both aim to provide thread-safety, their implementations and performance characteristics differ significantly. This post explores these differences in detail. What is a Synchronized HashMap? Created by wrapping a regular HashMap using: Map<K, V> syncMap = Collections.synchronizedMap(new HashMap<>()); Enforces synchronization at the object level , meaning only one thread can access the map at any time (read or write). Supports null keys and values since it relies on HashMap behavior. Iterators are fail-fast , throwing ConcurrentModificationException if the map is modified while iterating. Simpler implementation, suitable when concurrency is low or performance is not cri...
Read more