---
name: jabrena/125-java-concurrency
source: https://app.decimal.ai/s/jabrena-125-java-concurrency@1/SKILL.md
source_sha256: 9e5fb099baf4
---

# Java rules for Concurrency objects

Identify and apply Java concurrency best practices to improve thread safety, scalability, and maintainability by using modern `java.util.concurrent` utilities and virtual threads.

**What is covered in this Skill?**

- Thread safety fundamentals: `ConcurrentHashMap`, `AtomicInteger`, `ReentrantLock`, `ReadWriteLock`, Java Memory Model
- `ExecutorService` thread pool configuration: sizing, keep-alive, bounded queues, rejection policies, graceful shutdown
- Producer-Consumer and Publish-Subscribe patterns with `BlockingQueue`
- `CompletableFuture` for non-blocking async composition (`thenApply`/`thenCompose`/`exceptionally`/`orTimeout`)
- Immutability and safe publication (`volatile`, static initializers)
- Lock contention and false-sharing performance optimization
- Virtual threads (`Executors.newVirtualThreadPerTaskExecutor()`) for I/O-bound scalability
- Structured Concurrency (`StructuredTaskScope`) for related subtasks in Java 27 preview
- `ScopedValue` over `ThreadLocal` for immutable cross-task data
- Cooperative cancellation and `InterruptedException` discipline
- Backpressure with bounded queues and `CallerRunsPolicy`
- Deadlock avoidance via global lock ordering and `tryLock` with timeouts
- ForkJoin/parallel-stream discipline for CPU-bound work
- Virtual-thread pinning detection (JFR `VirtualThreadPinned`)
- Thread naming and `UncaughtExceptionHandler` observability
- Fit-for-purpose primitives: `LongAdder`, `CopyOnWriteArrayList`, `StampedLock`, `Semaphore`, `CountDownLatch`, `Phaser`

**Scope:** The reference is organized by examples (good/bad code patterns) for each core area. Apply recommendations based on applicable examples.

## Constraints

Before applying any concurrency changes, ensure the project compiles. If compilation fails, stop immediately — compilation failure is a blocking condition. After applying improvements, run full verification.

- **MANDATORY**: Run `./mvnw compile` or `mvn compile` before applying any change
- **SAFETY**: If compilation fails, stop immediately — compilation failure is a blocking condition that prevents any further processing
- **VERIFY**: Run `./mvnw clean verify` or `mvn clean verify` after applying improvements
- **BEFORE APPLYING**: Read the reference for detailed good/bad examples, constraints, and safeguards for each concurrency pattern

## When to use this skill

- Review Java code for concurrency
- Review Java code for thread safety
- Fix race conditions in Java concurrency code
- Choose ExecutorService or virtual threads in Java
- Improve synchronization and shared mutable state handling
- Apply structured concurrency for related Java subtasks

## Workflow

1. **Compile project before concurrency changes**

Run `./mvnw compile` or `mvn compile` and stop immediately if compilation fails.

2. **Read concurrency reference and analyze hotspots**

Read `references/125-java-concurrency.md` and identify thread-safety, coordination, and throughput issues to address.

3. **Apply concurrency improvements**

Implement suitable concurrency patterns, structured task scopes where they fit related subtasks, cancellation discipline, and fit-for-purpose primitives.

4. **Verify with full build**

Run `./mvnw clean verify` or `mvn clean verify` after applying improvements.

## Reference

For detailed guidance, examples, and constraints, see [references/125-java-concurrency.md](references/125-java-concurrency.md).