1
NEW ──start()──▶ RUNNABLE ─────────────────────▶ TERMINATED
2
                    │  ▲
3
                    │  │
4
              wait/│  │notify/notifyAll
5
              join/│  │
6
              lock │  │
7
                    ▼  │
8
                 BLOCKED / WAITING / TIMED_WAITING

1
Thread t = new Thread(() -> { ... });
2

3
// 启动
4
t.start();
5

6
// 当前线程
7
Thread.currentThread();
8
Thread.currentThread().getName();
9
Thread.currentThread().getId();
10

11
// 睡眠（毫秒）
12
Thread.sleep(1000);           // 当前线程暂停 1 秒，不释放锁
13

14
// 等待另一个线程结束
15
t.join();                     // 当前线程等 t 结束
16
t.join(5000);                 // 最多等 5 秒
17

18
// 中断（协作式）
19
t.interrupt();                // 给 t 发中断信号
20
t.isInterrupted();            // 查询是否被中断（不清除标志）
21
Thread.interrupted();         // 查询并清除标志
22

23
// 优先级（1~10，默认 5，仅供 JVM 参考，不保证）
24
t.setPriority(Thread.MAX_PRIORITY);
25

26
// 守护线程：所有非守护线程结束时，JVM 退出（不管守护线程）
27
t.setDaemon(true);            // 必须在 start() 之前设置
28

29
// 让步（提示调度器，不保证）
30
Thread.yield();
31

32
// 静态工厂（JDK 21+ 虚拟线程，另讲）
33
Thread vt = Thread.ofVirtual().start(() -> { ... });

1
public class RaceCondition {
2
    static int count = 0;
3

4
    public static void main(String[] args) throws InterruptedException {
5
        Runnable task = () -> {
6
            for (int i = 0; i < 100_000; i++) count++;
7
        };
8

9
        Thread t1 = new Thread(task);
10
        Thread t2 = new Thread(task);
11
        t1.start(); t2.start();
12
        t1.join(); t2.join();
13

14
        System.out.println(count);   // 期望 200000，实际可能是 130000~199999
15
    }
16
}

1
public class Deadlock {
2
    static Object lockA = new Object();
3
    static Object lockB = new Object();
4

5
    public static void main(String[] args) {
6
        new Thread(() -> {
7
            synchronized (lockA) {
8
                sleep(100);
9
                synchronized (lockB) {       // 等待线程 2 释放 lockB
10
                    System.out.println("线程 1 完成");
11
                }
12
            }
13
        }).start();
14

15
        new Thread(() -> {
16
            synchronized (lockB) {
17
                sleep(100);
18
                synchronized (lockA) {       // 等待线程 1 释放 lockA → 死锁
19
                    System.out.println("线程 2 完成");
20
                }
21
            }
22
        }).start();
23
    }
24
}

1
import java.util.concurrent.*;
2

3
ExecutorService executor = Executors.newFixedThreadPool(10);   // 固定 10 个线程
4

5
// 提交任务
6
executor.submit(() -> System.out.println("task 1"));
7
executor.submit(() -> System.out.println("task 2"));
8

9
// 提交有返回值的任务
10
Future<Integer> future = executor.submit(() -> 42);
11
Integer result = future.get();          // 阻塞等待
12

13
// 优雅关闭
14
executor.shutdown();                    // 不再接受新任务，等已提交的执行完
15
executor.awaitTermination(60, TimeUnit.SECONDS);
16

17
// 强制关闭
18
executor.shutdownNow();                 // 中断所有任务

1
// ConcurrentHashMap：线程安全的 HashMap
2
Map<String, Integer> map = new ConcurrentHashMap<>();
3
map.put("a", 1);
4
map.computeIfAbsent("b", k -> 2);
5
map.merge("a", 1, Integer::sum);         // 原子操作
6

7
// CopyOnWriteArrayList：读多写少
8
List<String> list = new CopyOnWriteArrayList<>();
9
list.add("a");
10
for (String s : list) { ... }            // 迭代不会抛 ConcurrentModificationException
11

12
// BlockingQueue：生产者消费者
13
BlockingQueue<String> queue = new LinkedBlockingQueue<>(100);
14
queue.put("item");                       // 队列满时阻塞
15
String item = queue.take();              // 队列空时阻塞
16
queue.offer("item", 5, TimeUnit.SECONDS); // 超时放弃

1
// ❌ 不是原子的
2
if (!map.containsKey("k")) {
3
    map.put("k", v);
4
}
5

6
// ✅ 用原子方法
7
map.putIfAbsent("k", v);
8
map.computeIfAbsent("k", key -> computeValue());

1
import java.util.concurrent.locks.ReentrantLock;
2

3
ReentrantLock lock = new ReentrantLock();
4

5
// 基本用法
6
lock.lock();
7
try {
8
    // 临界区
9
} finally {
10
    lock.unlock();     // 必须在 finally 里释放！
11
}
12

13
// 尝试加锁（非阻塞）
14
if (lock.tryLock()) {
15
    try { ... } finally { lock.unlock(); }
16
} else {
17
    // 没拿到锁
18
}
19

20
// 超时尝试
21
if (lock.tryLock(1, TimeUnit.SECONDS)) {
22
    try { ... } finally { lock.unlock(); }
23
}
24

25
// 公平锁：按等待顺序分配
26
ReentrantLock fairLock = new ReentrantLock(true);
27

28
// 可中断的加锁
29
lock.lockInterruptibly();

1
public class UserContext {
2
    private static final ThreadLocal<String> CURRENT_USER = new ThreadLocal<>();
3

4
    public static void set(String user) { CURRENT_USER.set(user); }
5
    public static String get() { return CURRENT_USER.get(); }
6
    public static void clear() { CURRENT_USER.remove(); }
7
}
8

9
// 使用
10
UserContext.set("Tom");
11
System.out.println(UserContext.get());   // "Tom"
12

13
// 线程池场景务必 clear，避免内存泄漏
14
try {
15
    UserContext.set("Tom");
16
    // 业务代码
17
} finally {
18
    UserContext.clear();
19
}

1
// 传统平台线程：受 OS 限制，最多几千个
2
Thread t = new Thread(() -> work());
3

4
// 虚拟线程：轻量级，可以创建百万个
5
Thread vt = Thread.ofVirtual().start(() -> work());
6

7
// 用 ExecutorService 更方便
8
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
9
    for (int i = 0; i < 1_000_000; i++) {
10
        executor.submit(() -> {
11
            Thread.sleep(1000);
12
            return "done";
13
        });
14
    }
15
}

1
// 创建线程
2
Thread t = new Thread(() -> work());
3
t.start();
4

5
// Callable + Future
6
ExecutorService exec = Executors.newFixedThreadPool(10);
7
Future<Integer> f = exec.submit(() -> 42);
8
Integer r = f.get();
9
exec.shutdown();
10

11
// 线程安全：三选一
12
synchronized (lock) { count++; }        // 加锁
13
private volatile boolean running;       // 仅可见性
14
AtomicInteger count = new AtomicInteger();   // 无锁
15

16
// 死锁避免：固定加锁顺序 + tryLock 超时
17

18
// CompletableFuture（Java 版 Promise）
19
CompletableFuture.supplyAsync(() -> work())
20
    .thenApply(String::length)
21
    .thenAccept(System.out::println)
22
    .exceptionally(ex -> { log.error("", ex); return null; });
23

24
CompletableFuture.allOf(f1, f2).join();
25

26
// 并发集合
27
ConcurrentHashMap<K, V>       // 替代 HashMap
28
CopyOnWriteArrayList<E>       // 替代 ArrayList（读多写少）
29
LinkedBlockingQueue<E>        // 生产者-消费者
30

31
// Lock
32
ReentrantLock lock = new ReentrantLock();
33
lock.lock();
34
try { ... } finally { lock.unlock(); }
35

36
if (lock.tryLock(1, TimeUnit.SECONDS)) {
37
    try { ... } finally { lock.unlock(); }
38
}
39

40
// ThreadLocal（记得 remove）
41
ThreadLocal<User> ctx = new ThreadLocal<>();
42
try { ctx.set(user); ... } finally { ctx.remove(); }
43

44
// 虚拟线程（JDK 21+）
45
Thread.ofVirtual().start(() -> work());
46
Executors.newVirtualThreadPerTaskExecutor();