1
// 1. 实现 Runnable 接口（无返回值、不抛受检异常）
2
Runnable runnableTask = () -> System.out.println(Thread.currentThread().getName() + " 执行任务");
3
new Thread(runnableTask).start();
4

5
// 2. 实现 Callable 配合 FutureTask（有返回值、可抛异常）
6
Callable<String> callableTask = () -> {
7
    // 可以声明 throws Exception
8
    return "计算结果: 100";
9
};
10
FutureTask<String> futureTask = new FutureTask<>(callableTask);
11
new Thread(futureTask).start();
12
String result = futureTask.get(); // 阻塞获取异步结果
13

14
// 3. 线程池规范创建（推荐）
15
ExecutorService pool = new ThreadPoolExecutor(
16
    2, 4, 60, TimeUnit.SECONDS,
17
    new ArrayBlockingQueue<>(100),
18
    Executors.defaultThreadFactory(),
19
    new ThreadPoolExecutor.CallerRunsPolicy()
20
);
21
pool.execute(runnableTask);
22
pool.shutdown();

1
// 方式 A：主线程流式 join
2
Thread t1 = new Thread(() -> System.out.println("T1 执行完毕"));
3
Thread t2 = new Thread(() -> System.out.println("T2 执行完毕"));
4
Thread t3 = new Thread(() -> System.out.println("T3 执行完毕"));
5

6
t1.start();
7
t1.join(); // 主线程阻塞，直到 t1 结束
8

9
t2.start();
10
t2.join(); // 主线程阻塞，直到 t2 结束
11

12
t3.start();
13
t3.join();
14

15
// 方式 B：CompletableFuture 现代链式异步编排（推荐）
16
CompletableFuture.runAsync(() -> System.out.println("任务1"))
17
    .thenRun(() -> System.out.println("任务2"))
18
    .thenRun(() -> System.out.println("任务3"));

1
public class WaitVsSleepDemo {
2
    private static final Object lock = new Object();
3

4
    // 1. 验证 sleep 不释放锁
5
    public static void testSleep() throws InterruptedException {
6
        new Thread(() -> {
7
            synchronized (lock) {
8
                System.out.println("线程1：获取锁，开始 sleep 2秒（不放锁）...");
9
                try {
10
                    Thread.sleep(2000); // 抱着锁睡
11
                } catch (InterruptedException e) {}
12
                System.out.println("线程1：sleep 结束，出同步块释放锁。");
13
            }
14
        }).start();
15

16
        Thread.sleep(100); // 确保线程1先拿锁
17

18
        new Thread(() -> {
19
            System.out.println("线程2：尝试获取锁...");
20
            synchronized (lock) {
21
                // 必须等线程1 sleep 完释放锁后，线程2才能打出这句
22
                System.out.println("线程2：终于获取到了锁！");
23
            }
24
        }).start();
25
    }
26

27
    // 2. 验证 wait 释放锁
28
    public static void testWait() throws InterruptedException {
29
        new Thread(() -> {
30
            synchronized (lock) {
31
                System.out.println("线程A：拿到锁，调用 wait() 立刻释放锁并等待...");
32
                try {
33
                    lock.wait(); // 交出锁，进入 WAITING
34
                } catch (InterruptedException e) {}
35
                System.out.println("线程A：重新被唤醒并拿回锁，继续执行！");
36
            }
37
        }).start();
38

39
        Thread.sleep(100); // 确保线程A先拿到锁并 wait
40

41
        new Thread(() -> {
42
            System.out.println("线程B：尝试获取锁...");
43
            synchronized (lock) {
44
                // 因为线程A wait 释放了锁，线程B可以立刻拿到锁进门
45
                System.out.println("线程B：拿到锁进门！通知唤醒线程A...");
46
                lock.notify(); // 唤醒等待线程A
47
                System.out.println("线程B：即将退出同步块并彻底释放锁。");
48
            }
49
        }).start();
50
    }
51
}

1
synchronized (lock) {
2
    // 必须使用 while 循环检查等待条件，禁止使用 if
3
    while (!conditionSatisfied) {
4
        lock.wait();
5
    }
6
    // 执行业务操作
7
    doSomething();
8
    // 优先使用 notifyAll() 防止信号丢失/假死
9
    lock.notifyAll();
10
}

1
public class SafeThreadStopDemo {
2
    public static void main(String[] args) throws InterruptedException {
3
        Thread worker = new Thread(() -> {
4
            // 1. 正常循环时检查打断标志位
5
            while (!Thread.currentThread().isInterrupted()) {
6
                try {
7
                    System.out.println("工作线程：正在执行业务任务...");
8
                    Thread.sleep(1000); // 模拟阻塞耗时
9
                } catch (InterruptedException e) {
10
                    System.out.println("工作线程：休眠中检测到中断信号！");
11
                    // 2. 发生异常时标志位被重置，可重新补齐标记或直接 break
12
                    Thread.currentThread().interrupt();
13
                    break; // 安全退出循环
14
                }
15
            }
16
            // 3. 释放资源，体面退出
17
            System.out.println("工作线程：资源清理完成，安全终止。");
18
        });
19

20
        worker.start();
21
        Thread.sleep(2500);
22
        System.out.println("主线程：发出中断信号 worker.interrupt()...");
23
        worker.interrupt();
24
    }
25
}

1
public class SyncDemo {
2
    private final Object lock = new Object();
3

4
    public void test() {
5
        synchronized (lock) {
6
            System.out.println("execute");
7
        }
8
    }
9
}

1
 5: monitorenter          // 1. 获取 monitor 锁，_owner 指向当前线程，_recursions 计数 +1
2
 6: getstatic     #3      // 输出执行代码...
3
 9: ldc           #4
4
11: invokevirtual #5
5
14: aload_1
6
15: monitorexit           // 2. 正常执行完毕退出，释放锁
7
16: goto          24
8
19: astore_2              // 3. 异常处理入口（Exception table 捕获异常）
9
20: aload_1
10
21: monitorexit           // 4. 异常退出路径：强制执行第 2 个 monitorexit，防止死锁
11
22: aload_2
12
23: athrow
13
24: return
14
Exception table:
15
   from    to  target type
16
       6    16    19   any   // 覆盖 6~16 行的所有异常
17
      19    22    19   any

1
  [新建对象]
2
      │
3
      ▼
4
   【无锁状态】
5
      │ (单线程首次进入同步块)
6
      ▼
7
   【偏向锁】 ──── (Mark Word 记录 Thread ID，后续无 CAS 免检通行)
8
      │
9
      │ (出现第二个线程轻度交替竞争，触发偏向锁撤销)
10
      ▼
11
  【轻量级锁】 ──── (Mark Word 指向当前线程栈帧的 Lock Record)
12
      │           (线程通过 CAS 原地自旋尝试获取锁，不挂起)
13
      │
14
      │ (自旋达到自适应上限仍未拿到锁，或多线程并发激烈强争)
15
      ▼
16
  【重量级锁】 ──── (Mark Word 指向堆外 C++ 的 ObjectMonitor 对象)
17
                   (未获得锁的线程由 OS 内核挂起，进入 BLOCKED 状态)

1
低竞争：
2
T1：|------持锁------|释放
3
T2：                       |----持锁----|

1
高竞争：
2
T1：|------------持锁------------|释放
3
T2：       尝试加锁 → 等待
4
T3：          尝试加锁 → 等待

1
import java.util.concurrent.atomic.AtomicStampedReference;
2

3
public class ABASolutionDemo {
4
    // 初始值 A，初始版本号 1
5
    private static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 1);
6

7
    public static void main(String[] args) {
8
        int stamp = ref.getStamp(); // 获取当前版本号
9

10
        // 模拟其他线程产生 ABA 操作：A -> B -> A（版本号持续递增）
11
        ref.compareAndSet("A", "B", stamp, stamp + 1);
12
        ref.compareAndSet("B", "A", ref.getStamp(), ref.getStamp() + 1);
13

14
        // 原线程尝试基于旧版本号修改，预期失败
15
        boolean success = ref.compareAndSet("A", "C", stamp, stamp + 1);
16
        System.out.println("CAS 修改是否成功: " + success); // 输出 false，成功拦截 ABA 问题
17
    }
18
}

1
public class Singleton {
2
    // 必须加 volatile：禁止 new 对象时的指令重排序，并保证多线程下的实例可见性
3
    private static volatile Singleton instance;
4

5
    private Singleton() {}
6

7
    public static Singleton getInstance() {
8
        if (instance == null) { // 第一重检查：提升性能，避免每次都加锁
9
            synchronized (Singleton.class) {
10
                if (instance == null) { // 第二重检查：防止多线程并发突破第一重后重复创建
11
                    // 底层分三步：1.分配空间 2.初始化 3.引用赋值
12
                    // volatile 禁止 2 和 3 重排序，彻底杜绝半成品对象逸出
13
                    instance = new Singleton();
14
                }
15
            }
16
        }
17
        return instance;
18
    }
19
}

1
      ┌────────────────────────────────────────────────────────┐
2
      │  AQS: volatile int state (0:无锁, >=1:加锁及重入次数)    │
3
      │  Thread exclusiveOwnerThread (当前持有锁的线程)         │
4
      └────────────────────────────────────────────────────────┘
5
                                 │
6
                   (抢锁失败进入双向 FIFO 阻塞队列)
7
                                 ▼
8
      ┌──────┐    next    ┌──────┐    next    ┌──────┐
9
      │ Head │ ─────────> │ Node │ ─────────> │ Tail │
10
      │ (哨兵)│ <───────── │(Thread)│ <───────── │(Thread)│
11
      └──────┘    prev    └──────┘    prev    └──────┘
12
                              │
13
                    LockSupport.park() 挂起

1
import java.util.concurrent.locks.Condition;
2
import java.util.concurrent.locks.Lock;
3
import java.util.concurrent.locks.ReentrantLock;
4

5
public class ReentrantLockDemo {
6
    // 默认非公平锁，构造传 true 为公平锁
7
    private final Lock lock = new ReentrantLock();
8
    // 绑定不同的条件队列，实现定向精确唤醒
9
    private final Condition condition = lock.newCondition();
10

11
    public void doWork() {
12
        lock.lock(); // 1. 手动加锁
13
        try {
14
            System.out.println(Thread.currentThread().getName() + " 获取到锁，执行业务");
15
            condition.await(); // 等待特定条件，释放锁并等待
16
        } catch (InterruptedException e) {
17
            System.out.println("等锁或等待条件过程中被中断");
18
        } finally {
19
            // 2. 铁律：必须在 finally 中显式释放锁，防止业务异常引发死锁
20
            lock.unlock();
21
            System.out.println(Thread.currentThread().getName() + " 释放锁");
22
        }
23
    }
24
}

1
package com.itheima.lock;
2

3
import java.util.concurrent.TimeUnit;
4
import java.util.concurrent.locks.Condition;
5
import java.util.concurrent.locks.ReentrantLock;
6

7
public class ReentrantLockTest {
8

9
    static ReentrantLock lock = new ReentrantLock();
10
    static Condition c1 = lock.newCondition();
11
    static Condition c2 = lock.newCondition();
12

13
    public static void main(String[] args) throws InterruptedException {
14
        // 1. 可打断测试: lockInterrupt();
15
        // 2. 可超时测试: timeOutLock();
16
        // 3. 多条件变量测试: conditionTest();
17
    }
18

19
    // 1. 可打断获取锁
20
    public static void lockInterrupt() throws InterruptedException {
21
        Thread t1 = new Thread(() -> {
22
            try {
23
                lock.lockInterruptibly(); // 尝试获取锁，但允许被中断
24
            } catch (InterruptedException e) {
25
                System.out.println("等待锁的过程中被打断，安全放弃");
26
                return;
27
            }
28
            try {
29
                System.out.println(Thread.currentThread().getName() + " 获得了锁");
30
            } finally {
31
                lock.unlock();
32
            }
33
        }, "t1");
34

35
        lock.lock();
36
        t1.start();
37
        Thread.sleep(1000);
38
        t1.interrupt(); // 主线程打断 t1，t1 响应中断退出，不陷入死锁
39
        lock.unlock();
40
    }
41

42
    // 2. 超时尝试拿锁
43
    public static void timeOutLock() throws InterruptedException {
44
        Thread t1 = new Thread(() -> {
45
            try {
46
                if (!lock.tryLock(2, TimeUnit.SECONDS)) { // 最多等 2 秒
47
                    System.out.println("t1 获取锁超时，降级处理");
48
                    return;
49
                }
50
            } catch (InterruptedException e) {
51
                return;
52
            }
53
            try {
54
                System.out.println("t1 获得了锁");
55
            } finally {
56
                lock.unlock();
57
            }
58
        }, "t1");
59

60
        lock.lock();
61
        t1.start();
62
        Thread.sleep(3000); // 占用锁 3 秒，促使 t1 超时
63
        lock.unlock();
64
    }
65

66
    // 3. 多条件队列精准唤醒
67
    public static void conditionTest() {
68
        new Thread(() -> {
69
            lock.lock();
70
            try {
71
                c1.await(); // 进入 c1 等待队列
72
                System.out.println("t1 (c1) 被唤醒并获得锁");
73
            } catch (InterruptedException e) {}
74
            finally { lock.unlock(); }
75
        }, "t1").start();
76

77
        new Thread(() -> {
78
            lock.lock();
79
            try {
80
                c2.await(); // 进入 c2 等待队列
81
                System.out.println("t2 (c2) 被唤醒并获得锁");
82
            } catch (InterruptedException e) {}
83
            finally { lock.unlock(); }
84
        }, "t2").start();
85

86
        new Thread(() -> {
87
            lock.lock();
88
            try {
89
                c1.signalAll(); // 仅唤醒等待 c1 的 t1，不会惊动等待 c2 的 t2
90
            } finally { lock.unlock(); }
91
        }, "t3").start();
92
    }
93
}

1
Found one Java-level deadlock:
2
=============================
3
"Thread-1":
4
  waiting to lock monitor 0x00007f (object 0x111, a java.lang.Object),
5
  which is held by "Thread-0"
6
"Thread-0":
7
  waiting to lock monitor 0x00008f (object 0x222, a java.lang.Object),
8
  which is held by "Thread-1"
9

10
Java stack information for the threads listed above:
11
===================================================
12
"Thread-1":
13
        at DeadLockDemo.lambda$main$1(DeadLockDemo.java:23)
14
        - waiting to lock <0x111> (a java.lang.Object)
15
        - locked <0x222> (a java.lang.Object)
16
"Thread-0":
17
        at DeadLockDemo.lambda$main$0(DeadLockDemo.java:12)
18
        - waiting to lock <0x222> (a java.lang.Object)
19
        - locked <0x111> (a java.lang.Object)
20

21
Found 1 deadlock.

1
// 错误示范：复合操作仍然存在并发竞态条件
2
if (!map.containsKey(key)) {
3
    map.put(key, value);
4
}
5

6
// 正确示范：使用底层原子复合方法
7
map.putIfAbsent(key, value);
8
// 或使用函数式原子更新
9
map.computeIfAbsent(key, k -> computeValue(k));

1
package com.itheima.threadpool;
2

3
import java.lang.reflect.Field;
4
import java.util.ArrayList;
5
import java.util.List;
6
import java.util.concurrent.*;
7
import java.util.concurrent.atomic.AtomicInteger;
8

9
public class TestThreadPoolExecutor {
10

11
    static class MyTask implements Runnable {
12
        private final String name;
13
        private final long duration;
14

15
        public MyTask(String name) {
16
            this(name, 0);
17
        }
18

19
        public MyTask(String name, long duration) {
20
            this.name = name;
21
            this.duration = duration;
22
        }
23

24
        @Override
25
        public void run() {
26
            try {
27
                LoggerUtils.get("myThread").debug("running..." + this);
28
                Thread.sleep(duration);
29
            } catch (InterruptedException e) {
30
                e.printStackTrace();
31
            }
32
        }
33

34
        @Override
35
        public String toString() {
36
            return "MyTask(" + name + ")";
37
        }
38
    }
39

40
    public static void main(String[] args) throws InterruptedException {
41
        AtomicInteger c = new AtomicInteger(1);
42
        ArrayBlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(2);
43

44
        LinkedBlockingQueue linkedBlockingQueue = new LinkedBlockingQueue();
45
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
46
                2, //核心线程数
47
                3, //最大线程数
48
                0, //应急线程存活时间
49
                TimeUnit.MILLISECONDS, // 应急线程存活单位
50
                queue, // 阻塞队列
51
                r -> new Thread(r, "myThread" + c.getAndIncrement()), // 线程工厂
52
                new ThreadPoolExecutor.AbortPolicy()); //拒绝策略
53
        showState(queue, threadPool);
54
        threadPool.submit(new MyTask("1", 3600000));
55
        showState(queue, threadPool);
56
        threadPool.submit(new MyTask("2", 3600000));
57
        showState(queue, threadPool);
58
        threadPool.submit(new MyTask("3"));
59
        showState(queue, threadPool);
60
        threadPool.submit(new MyTask("4"));
61
        showState(queue, threadPool);
62
        threadPool.submit(new MyTask("5",3600000));
63
        showState(queue, threadPool);
64
        threadPool.submit(new MyTask("6"));
65
        showState(queue, threadPool);
66
    }
67

68
    private static void showState(ArrayBlockingQueue<Runnable> queue, ThreadPoolExecutor threadPool) {
69
        try {
70
            Thread.sleep(300);
71
        } catch (InterruptedException e) {
72
            e.printStackTrace();
73
        }
74
        List<Object> tasks = new ArrayList<>();
75
        for (Runnable runnable : queue) {
76
            try {
77
                Field callable = FutureTask.class.getDeclaredField("callable");
78
                callable.setAccessible(true);
79
                Object adapter = callable.get(runnable);
80
                Class<?> clazz = Class.forName("java.util.concurrent.Executors$RunnableAdapter");
81
                Field task = clazz.getDeclaredField("task");
82
                task.setAccessible(true);
83
                Object o = task.get(adapter);
84
                tasks.add(o);
85
            } catch (Exception e) {
86
                e.printStackTrace();
87
            }
88
        }
89
        LoggerUtils.main.debug("pool size: {}, queue: {}", threadPool.getPoolSize(), tasks);
90
    }
91

92
}

1
package com.itheima.application;
2

3
import java.util.concurrent.CountDownLatch;
4

5
public class CountDownLatchDemo {
6

7
    public static void main(String[] args) throws InterruptedException {
8
        //初始化了一个倒计时锁 参数为 3
9
        CountDownLatch latch = new CountDownLatch(3);
10

11
        new Thread(() -> {
12
            System.out.println(Thread.currentThread().getName()+"-begin...");
13
            try {
14
                Thread.sleep(1000);
15
            } catch (InterruptedException e) {
16
                throw new RuntimeException(e);
17
            }
18
            //count--
19
            latch.countDown();
20
            System.out.println(Thread.currentThread().getName()+"-end..." +latch.getCount());
21
        }).start();
22
        new Thread(() -> {
23
            System.out.println(Thread.currentThread().getName()+"-begin...");
24
            try {
25
                Thread.sleep(2000);
26
            } catch (InterruptedException e) {
27
                throw new RuntimeException(e);
28
            }
29
            //count--
30
            latch.countDown();
31
            System.out.println(Thread.currentThread().getName()+"-end..." +latch.getCount());
32
        }).start();
33
        new Thread(() -> {
34
            System.out.println(Thread.currentThread().getName()+"-begin...");
35
            try {
36
                Thread.sleep(1500);
37
            } catch (InterruptedException e) {
38
                throw new RuntimeException(e);
39
            }
40
            //count--
41
            latch.countDown();
42
            System.out.println(Thread.currentThread().getName()+"-end..." +latch.getCount());
43
        }).start();
44
        String name = Thread.currentThread().getName();
45
        System.out.println(name + "-waiting...");
46
        //等待其他线程完成
47
        latch.await();
48
        System.out.println(name + "-wait end...");
49
    }
50

51
}