name	effective-java-concurrency
description	Apply Effective Java (2nd edition) concurrency best practices when writing or reviewing multi-threaded Java code: synchronization/visibility, avoiding excessive locking, executors, concurrency utilities, thread-safety docs, lazy init, scheduler independence, and avoiding thread groups.

Effective Java Concurrency (2nd ed)

Guideline checklist derived from docs/effective_java.md (Bloch, Effective Java 2nd edition, Items 66-73). If another repo skill sets stricter rules, follow the stricter one.

Quick workflow

Identify all shared mutable state and define the locking/visibility policy.
Prefer not sharing mutable state at all (immutability, confinement, or safe publication).
Prefer high-level concurrency utilities (executors, concurrent collections, synchronizers).
Keep synchronized regions small; avoid calling client/overridable code while holding locks.
Document the thread-safety guarantees and any required external locking.

Checklist by item (66-73)

66: Synchronize access to shared mutable data (mutual exclusion + visibility); use volatile only for visibility; use atomics for atomic updates.
67: Avoid excessive synchronization; do as little work as possible under lock; use open calls (move alien method calls outside locks).
68: Prefer executors and tasks to threads; use ExecutorService and thread pools; shut down executors cleanly.
69: Prefer concurrency utilities to wait/notify; use concurrent collections and synchronizers; if you must, use the wait-loop idiom and prefer notifyAll.
70: Document thread safety (immutable / unconditionally thread-safe / conditionally thread-safe / not thread-safe / thread-hostile); document which lock guards which state.
71: Use lazy initialization judiciously; prefer eager init; otherwise use holder idiom (static), synchronized accessors, or double-check idiom with volatile.
72: Do not depend on the thread scheduler for correctness or performance; avoid busy-wait and oversubscription.
73: Avoid thread groups (obsolete).

Common red flags

Unsynchronized read/write of shared mutable fields (especially "write without synchronization, read with synchronization" or vice versa).
volatile used for non-atomic compound actions (e.g., ++).
Calling callbacks / overridable methods while holding a lock.
Unbounded thread creation or "new Thread(...)" in library code instead of an executor.
wait() or notify() used outside the standard wait-loop idiom.

Getting the full details quickly

Prefer opening the smallest relevant reference file (same original structure + code blocks):

.codex/skills/effective-java-concurrency/references/10-concurrency.md

Legacy (large, avoid loading unless you truly need everything at once):

.codex/skills/effective-java-concurrency/references/effective_java.md

You can also search the repo source summary:

File: docs/effective_java.md
Find a specific item: rg -n '^## 66\\.' docs/effective_java.md

Effective Java Concurrency (2nd ed)

Guideline checklist derived from docs/effective_java.md (Bloch, Effective Java 2nd edition, Items 66-73). If another repo skill sets stricter rules, follow the stricter one.

Quick workflow

Identify all shared mutable state and define the locking/visibility policy.

Prefer not sharing mutable state at all (immutability, confinement, or safe publication).

Prefer high-level concurrency utilities (executors, concurrent collections, synchronizers).

Keep synchronized regions small; avoid calling client/overridable code while holding locks.

Document the thread-safety guarantees and any required external locking.

Checklist by item (66-73)

66: Synchronize access to shared mutable data (mutual exclusion + visibility); use volatile only for visibility; use atomics for atomic updates.

67: Avoid excessive synchronization; do as little work as possible under lock; use open calls (move alien method calls outside locks).

68: Prefer executors and tasks to threads; use ExecutorService and thread pools; shut down executors cleanly.

69: Prefer concurrency utilities to wait/notify; use concurrent collections and synchronizers; if you must, use the wait-loop idiom and prefer notifyAll.

70: Document thread safety (immutable / unconditionally thread-safe / conditionally thread-safe / not thread-safe / thread-hostile); document which lock guards which state.

71: Use lazy initialization judiciously; prefer eager init; otherwise use holder idiom (static), synchronized accessors, or double-check idiom with volatile.

72: Do not depend on the thread scheduler for correctness or performance; avoid busy-wait and oversubscription.

73: Avoid thread groups (obsolete).

Common red flags

Unsynchronized read/write of shared mutable fields (especially "write without synchronization, read with synchronization" or vice versa).

volatile used for non-atomic compound actions (e.g., ++).

Calling callbacks / overridable methods while holding a lock.

Unbounded thread creation or "new Thread(...)" in library code instead of an executor.

wait() or notify() used outside the standard wait-loop idiom.

Getting the full details quickly

Prefer opening the smallest relevant reference file (same original structure + code blocks):

.codex/skills/effective-java-concurrency/references/10-concurrency.md

Legacy (large, avoid loading unless you truly need everything at once):

.codex/skills/effective-java-concurrency/references/effective_java.md

You can also search the repo source summary:

File: docs/effective_java.md

Find a specific item: rg -n '^## 66\\.' docs/effective_java.md

effective-java-concurrency