java-concurrency
Master Java concurrency - threads, executors, locks, CompletableFuture, virtual threads
When & Why to Use This Skill
This Java Concurrency skill empowers developers to build high-performance, thread-safe applications by mastering complex multithreading patterns. It covers the full spectrum of Java concurrency, from foundational thread management and synchronization to modern asynchronous patterns like CompletableFuture and high-scalability Virtual Threads (Java 21). By providing expert guidance on thread pool tuning and deadlock prevention, it ensures efficient resource utilization and robust system architecture.
Use Cases
- Implementing high-throughput parallel processing using Java 21 Virtual Threads to handle massive concurrent workloads with minimal overhead.
- Designing thread-safe components using advanced synchronization primitives like ReentrantLock, volatile, and Atomic variables to eliminate race conditions.
- Optimizing system performance by configuring and tuning ThreadPoolExecutor parameters specifically for CPU-bound or I/O-bound tasks.
- Developing non-blocking, asynchronous service pipelines using CompletableFuture for efficient API orchestration and error handling.
- Debugging and resolving complex concurrency issues such as deadlocks, thread starvation, and memory consistency errors using best-practice patterns.
| name | java-concurrency |
|---|---|
| description | Master Java concurrency - threads, executors, locks, CompletableFuture, virtual threads |
| sasmp_version | "1.3.0" |
| version | "3.0.0" |
| bonded_agent | 02-java-advanced |
| bond_type | PRIMARY_BOND |
| allowed-tools | Read, Write, Bash, Glob, Grep |
| type | string |
| enum | [threads, executors, virtual_threads, reactive] |
| default | "21" |
Java Concurrency Skill
Master Java concurrency patterns for thread-safe applications.
Overview
This skill covers concurrency from basic threads to virtual threads (Java 21+), including thread pools, synchronization, and CompletableFuture.
When to Use This Skill
Use when you need to:
- Write thread-safe code
- Implement parallel processing
- Use async programming patterns
- Tune thread pools
- Debug concurrency issues
Topics Covered
Thread Management
- Thread lifecycle and states
- Daemon vs user threads
- Interrupt handling
Synchronization
- synchronized, volatile
- Lock interfaces (ReentrantLock)
- Atomic operations
Executors
- ThreadPoolExecutor configuration
- ForkJoinPool
- Virtual Threads (Java 21+)
CompletableFuture
- Async execution
- Chaining and composition
- Exception handling
Quick Reference
// Virtual Threads (Java 21+)
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
IntStream.range(0, 10_000).forEach(i ->
executor.submit(() -> processRequest(i)));
}
// CompletableFuture composition
CompletableFuture<Result> result = fetchUser(id)
.thenCompose(user -> fetchOrders(user.id()))
.thenApply(orders -> processOrders(orders))
.exceptionally(ex -> handleError(ex))
.orTimeout(5, TimeUnit.SECONDS);
// Thread pool configuration
ThreadPoolExecutor executor = new ThreadPoolExecutor(
10, 50, 60L, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(1000),
new ThreadPoolExecutor.CallerRunsPolicy()
);
// Lock with timeout
ReentrantLock lock = new ReentrantLock();
if (lock.tryLock(1, TimeUnit.SECONDS)) {
try {
// critical section
} finally {
lock.unlock();
}
}
Thread Pool Sizing
| Workload | Formula | Example |
|---|---|---|
| CPU-bound | cores | 8 threads |
| I/O-bound | cores * (1 + wait/compute) | 80 threads |
Troubleshooting
| Problem | Cause | Solution |
|---|---|---|
| Deadlock | Circular lock | Lock ordering, tryLock |
| Race condition | Missing sync | Add locks/atomics |
| Thread starvation | Unfair scheduling | Fair locks |
Debug Commands
jstack -l <pid> > threaddump.txt
jcmd <pid> Thread.print
Usage
Skill("java-concurrency")