Multithreading lets a Java program run multiple threads concurrently, enabling parallelism (using multiple CPU cores) and responsiveness (doing work without blocking). Java has first-class thread support — but shared mutable state introduces complexity (race conditions) that must be managed carefully.
() -> System.out.println( + Thread.currentThread().getName());
(task);
t.start();
Executors.newFixedThreadPool();
executor.submit(task);
Key gotcha: call start() (spawns a new thread), not run() (which just runs the code on the current thread synchronously).
// ❌ multiple threads modifying shared state → unpredictable results
class Counter {
int count = 0;
void increment() { count++; } // NOT atomic: read → add → write (can interleave)
}
// 1000 threads each incrementing 1000 times → final count is often < 1,000,000!
count++ is actually three operations (read, increment, write). When threads interleave, updates get lost — a race condition. This is the central challenge of concurrency: shared mutable state accessed by multiple threads without coordination.
// 1. synchronized — only one thread in the method/block at a time (a lock)
synchronized void increment() { count++; }
// 2. atomic classes — lock-free atomic operations
AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet(); // atomic, thread-safe, efficient
// 3. concurrent collections — built for multi-threaded access
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
// 4. immutability — immutable objects are inherently thread-safe (nothing to corrupt)
t.join(); // wait for thread t to finish
Thread.sleep(1000); // pause the current thread
// also: wait()/notify(), CountDownLatch, locks, etc. for coordination
✓ Use ExecutorService / thread pools (not new Thread() per task — expensive)
✓ Use CompletableFuture for async composition
✓ Use concurrent collections and atomic classes over manual synchronization
✓ Java 21+ adds Virtual Threads — millions of lightweight threads for I/O concurrency
Multithreading enables Java programs to use multiple cores and stay responsive, but it's also one of the hardest areas to get right — race conditions from unsynchronized shared mutable state cause intermittent, hard-to-reproduce bugs.
Understanding how threads work (start() vs run()), the core race-condition problem (why count++ isn't safe), and the tools to ensure safety (synchronized, atomic classes, concurrent collections, immutability) is essential for writing correct concurrent code.
Modern best practice favors higher-level abstractions (ExecutorService, CompletableFuture, virtual threads) over raw thread management.
This is critical knowledge for server-side and high-performance Java, and a deep, frequently-tested topic that separates competent from expert developers.