关键陷阱： 调用 start()（生成新线程），而不是 run()（只在当前线程上同步运行代码）。
// ❌ 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++ 实际上是三个操作（读、增加、写）。当线程交错执行时，更新会丢失——这是一个 竞态条件。这是并发的中心挑战：多个线程在没有协调的情况下访问共享可变状态。
// 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 使 Java 程序能够使用多个核心并保持响应性，但这也是最难正确处理的领域之一——来自未同步共享可变状态的 竞态条件 会导致间歇性的、难以重现的 bug。
理解线程如何工作（start() 与 run()）、竞态条件的核心问题（为什么 count++ 不安全）以及确保安全的工具（synchronized、原子类、并发集合、不可变性）对于编写正确的并发代码至关重要。
现代最佳实践倾向于使用高级抽象（ExecutorService、CompletableFuture、虚拟线程）而不是原始线程管理。
这是服务端和高性能 Java 的关键知识，也是一个深度的、经常被测试的主题，可以区分胜任和专家级开发人员。