深入浅出Java并发多线程：核心基础+内存模型＋死锁——从用法到原理

// 方式一：继承 Thread（不推荐）
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}

// 方式二：实现 Runnable（推荐）
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable running");
    }
}

// 方式三：实现 Callable + FutureTask（获取返回值）
class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Callable result";
    }
}

// 使用示例
public static void main(String[] args) throws Exception {
    // Runnable 配合线程池使用更佳
    new Thread(new MyRunnable()).start();
    
    // Callable 获取返回值
    FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
    new Thread(futureTask).start();
    String result = futureTask.get(); // 阻塞等待结果
    System.out.println(result);
}

┌─────────────┐          ┌─────────────┐
│   线程 A     │──────────│   线程 B     │
└──────┬──────┘          └──────┬──────┘
       │ 写入                   │ 读取
       ▼                        ▼
┌─────────────┐          ┌─────────────┐
│  工作内存    │          │  工作内存    │
│ (CPU 缓存)   │          │ (CPU 缓存)   │
└──────┬──────┘          └──────┬──────┘
       │                        │
       └──────────┬─────────────┘
                  ▼
          ┌─────────────┐
          │   主内存     │
          │  (堆内存)    │
          └─────────────┘

// Java 代码
volatile boolean flag = true;

// JVM 字节码层面
// 在 volatile 写操作前后插入内存屏障
// StoreStoreBarrier → volatile 写 → StoreLoadBarrier
// LoadLoadBarrier → volatile 读 → LoadStoreBarrier

// x86 架构下，volatile 写会加上 lock 前缀指令
// lock addl $0x0,(%rsp)  —— 这是一个全屏障
inline void OrderAccess::fence() {
    if (os::is_MP()) {
        __asm__ volatile ("lock; addl $0,0(%%rsp)" : : : "cc", "memory");
    }
}

// 1. 实例方法锁 —— 锁的是当前实例对象 this
public synchronized void method1() { ... }

// 2. 静态方法锁 —— 锁的是 Class 对象
public static synchronized void method2() { ... }

// 3. 代码块锁 —— 最灵活，可指定锁对象
public void method3() {
    synchronized (this) { ... }
    synchronized (lockObject) { ... }
}

// 一段简单的同步代码块
public void add() {
    synchronized (this) {
        count++;
    }
}

// 对应的字节码
public void add();
    Code:
       0: aload_0          // 将 this 推入栈顶
       1: dup
       2: astore_1         // 存储到局部变量
       3: monitorenter     // ★ 进入同步块，获取锁
       4: aload_0
       5: dup
       6: getfield #2      // 获取 count 字段
       9: iconst_1
      10: iadd
      11: putfield #2      // 写回 count
      14: aload_1
      15: monitorexit      // ★ 退出同步块，释放锁
      16: goto 24
      19: astore_2
      20: aload_1
      21: monitorexit      // ★ 异常处理中也要释放锁
      22: aload_2
      23: athrow
      24: return

public class DeadlockDemo {
    private static final Object RESOURCE_A = new Object();
    private static final Object RESOURCE_B = new Object();

    public static void main(String[] args) {
        // 线程1：先拿 A，再拿 B
        Thread t1 = new Thread(() -> {
            synchronized (RESOURCE_A) {
                System.out.println("Thread1: 持有 A，等待 B...");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (RESOURCE_B) {
                    System.out.println("Thread1: 同时持有 A 和 B");
                }
            }
        });

        // 线程2：先拿 B，再拿 A —— 形成死锁
        Thread t2 = new Thread(() -> {
            synchronized (RESOURCE_B) {
                System.out.println("Thread2: 持有 B，等待 A...");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (RESOURCE_A) {
                    System.out.println("Thread2: 同时持有 A 和 B");
                }
            }
        });

        t1.start();
        t2.start();
    }
}

$ jps
12345 DeadlockDemo
12346 Jps

jstack 12345

Found one Java-level deadlock:
=============================
"Thread1":
  waiting to lock monitor 0x00007f... (object 0x... <-- RESOURCE_B)
  which is held by "Thread2"
"Thread2":
  waiting to lock monitor 0x00007f... (object 0x... <-- RESOURCE_A)
  which is held by "Thread1"

Java stack information for the threads listed above:
===================================================
Thread1:
    at DeadlockDemo.lambda$main$0(DeadlockDemo.java:15)
    - waiting to lock <0x...> (a java.lang.Object)
    - locked <0x...> (a java.lang.Object)
Thread2:
    at DeadlockDemo.lambda$main$1(DeadlockDemo.java:26)
    - waiting to lock <0x...> (a java.lang.Object)
    - locked <0x...> (a java.lang.Object)

// 使用 tryLock 避免死锁
public boolean transfer(ReentrantLock lockA, ReentrantLock lockB) {
    long timeout = 1000;
    while (true) {
        if (lockA.tryLock(timeout, TimeUnit.MILLISECONDS)) {
            try {
                if (lockB.tryLock(timeout, TimeUnit.MILLISECONDS)) {
                    try {
                        // 业务操作
                        return true;
                    } finally {
                        lockB.unlock();
                    }
                }
            } finally {
                lockA.unlock();
            }
        }
        // 超时重试
        if (--retryCount == 0) return false;
    }
}

// AQS 核心结构
public abstract class AbstractQueuedSynchronizer {
    private volatile int state;        // 同步状态
    private transient volatile Node head;  // CLH 队列头
    private transient volatile Node tail;  // CLH 队列尾
    
    // 尝试获取锁（由子类实现）
    protected boolean tryAcquire(int arg) { ... }
    // 尝试释放锁（由子类实现）
    protected boolean tryRelease(int arg) { ... }
}