Java并发第一性原理：为什么并发如此困难？

/**
 * 单线程秒杀服务
 * 优势：简单、可预测、无并发问题
 * 劣势：性能差，无法处理高并发
 */
public class SingleThreadSeckillService {
    private int stock = 100;  // 库存

    public synchronized boolean seckill(String userId) {
        // 检查库存
        if (stock <= 0) {
            System.out.println("库存不足，秒杀失败");
            return false;
        }

        // 模拟业务处理（数据库操作、支付调用等）
        try {
            Thread.sleep(10);  // 10ms的业务处理时间
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        // 扣减库存
        stock--;
        System.out.println("用户 " + userId + " 秒杀成功，剩余库存：" + stock);
        return true;
    }
}

// 性能测试
public class SingleThreadTest {
    public static void main(String[] args) {
        SingleThreadSeckillService service = new SingleThreadSeckillService();
        long start = System.currentTimeMillis();

        // 1000个用户顺序秒杀
        for (int i = 0; i < 1000; i++) {
            service.seckill("User-" + i);
        }

        long end = System.currentTimeMillis();
        System.out.println("总耗时：" + (end - start) + "ms");
    }
}

/*
执行结果：
总耗时：10,000ms（10秒）
分析：每个请求10ms，1000个请求串行执行，总计10秒
问题：在真实秒杀场景中，10秒是不可接受的响应时间
*/

/**
 * 多线程秒杀服务（错误示范）
 * 优势：性能大幅提升
 * 劣势：存在严重的并发Bug
 */
public class MultiThreadSeckillService {
    private int stock = 100;  // 库存（共享变量）

    public boolean seckill(String userId) {
        // 检查库存（问题1：可见性问题）
        if (stock <= 0) {
            System.out.println("库存不足，秒杀失败");
            return false;
        }

        // 模拟业务处理
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        // 扣减库存（问题2：原子性问题）
        stock--;  // 这不是原子操作！
        System.out.println("用户 " + userId + " 秒杀成功，剩余库存：" + stock);
        return true;
    }
}

// 多线程性能测试
public class MultiThreadTest {
    public static void main(String[] args) throws InterruptedException {
        MultiThreadSeckillService service = new MultiThreadSeckillService();
        CountDownLatch latch = new CountDownLatch(1000);

        long start = System.currentTimeMillis();

        // 1000个线程并发秒杀
        for (int i = 0; i < 1000; i++) {
            final int userId = i;
            new Thread(() -> {
                service.seckill("User-" + userId);
                latch.countDown();
            }).start();
        }

        latch.await();  // 等待所有线程完成
        long end = System.currentTimeMillis();
        System.out.println("总耗时：" + (end - start) + "ms");
    }
}

/*
执行结果（多次运行结果不一致）：
总耗时：50ms（相比单线程提升200倍！）
但是...

问题1：库存超卖
- 期望：100件商品，只有前100个用户秒杀成功
- 实际：可能有150个用户秒杀成功（库存变成-50）

问题2：最终库存不一致
- 第一次运行：最终库存 = -45
- 第二次运行：最终库存 = -52
- 第三次运行：最终库存 = -38
每次结果都不同！

问题3：可见性问题
- 有些线程读到的stock是过期值
- 线程A扣减库存后，线程B可能看不到最新值
*/

// 问题的本质：stock--不是原子操作
// stock-- 实际上分为三步：
// 1. 读取stock的值（READ）
// 2. 计算stock - 1（COMPUTE）
// 3. 写回stock（WRITE）

// 并发场景下的交错执行：
时间线：
t1: 线程A读取stock = 100
t2: 线程B读取stock = 100  （A还没写回）
t3: 线程A计算 100 - 1 = 99
t4: 线程B计算 100 - 1 = 99  （B也读到了100）
t5: 线程A写回 stock = 99
t6: 线程B写回 stock = 99  （覆盖了A的结果！）

结果：两个线程都秒杀成功，但库存只减少了1（应该减少2）

/**
 * 多线程秒杀服务（正确版本）
 * 使用synchronized保证线程安全
 */
public class SafeMultiThreadSeckillService {
    private int stock = 100;

    public synchronized boolean seckill(String userId) {
        // 检查库存
        if (stock <= 0) {
            System.out.println("库存不足，秒杀失败");
            return false;
        }

        // 模拟业务处理
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        // 扣减库存
        stock--;
        System.out.println("用户 " + userId + " 秒杀成功，剩余库存：" + stock);
        return true;
    }
}

/*
执行结果：
总耗时：1,000ms（1秒）
库存最终值：0（正确！）
成功用户数：100（正确！）

性能对比：
├─ 单线程：10,000ms
├─ 多线程（错误）：50ms（但结果错误）
└─ 多线程（正确）：1,000ms（结果正确，性能提升10倍）

结论：
虽然synchronized引入了同步开销，但相比单线程仍有10倍性能提升
关键是：正确性 > 性能
*/

/**
 * 可见性问题演示
 * 场景：线程A修改flag，线程B循环检查flag
 * 问题：B可能永远看不到A的修改
 */
public class VisibilityProblem {
    private static boolean flag = false;  // 共享变量

    public static void main(String[] args) throws InterruptedException {
        // 线程A：1秒后修改flag
        Thread threadA = new Thread(() -> {
            try {
                Thread.sleep(1000);
                flag = true;  // 修改flag
                System.out.println("线程A：flag已设置为true");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 线程B：循环检查flag
        Thread threadB = new Thread(() -> {
            while (!flag) {
                // 空循环，等待flag变为true
            }
            System.out.println("线程B：检测到flag = true，退出循环");
        });

        threadB.start();
        Thread.sleep(100);  // 确保B先启动
        threadA.start();

        threadA.join();
        threadB.join();
    }
}

/*
执行结果：
线程A：flag已设置为true
（然后程序卡住，线程B永远不会退出）

问题分析：
1. 线程B读取flag并缓存到CPU寄存器
2. 循环中一直读取寄存器的值（false）
3. 线程A修改的flag在主内存，B看不到
4. 即使A写入主内存，B的缓存也不会自动失效

解决方案1：使用volatile
private static volatile boolean flag = false;

解决方案2：使用synchronized
synchronized(lock) { flag = true; }
*/

/**
 * 原子性问题演示
 * 场景：1000个线程并发累加counter
 * 期望：最终结果10000
 * 实际：结果小于10000（每次不同）
 */
public class AtomicityProblem {
    private static int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[1000];

        for (int i = 0; i < 1000; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 10; j++) {
                    counter++;  // 非原子操作
                }
            });
        }

        // 启动所有线程
        for (Thread thread : threads) {
            thread.start();
        }

        // 等待所有线程完成
        for (Thread thread : threads) {
            thread.join();
        }

        System.out.println("最终结果：" + counter);
        System.out.println("期望结果：10000");
        System.out.println("丢失更新：" + (10000 - counter));
    }
}

/*
执行结果（多次运行）：
第1次：最终结果：9876  丢失更新：124
第2次：最终结果：9923  丢失更新：77
第3次：最终结果：9851  丢失更新：149

问题分析：
counter++ 分解为三步：
1. 读取counter（READ）
2. 加1（ADD）
3. 写回counter（WRITE）

并发场景下的交错执行：
时间  线程A              线程B
t1   READ(0)
t2                      READ(0)
t3   ADD(0+1=1)
t4                      ADD(0+1=1)
t5   WRITE(1)
t6                      WRITE(1)  ← 覆盖了A的结果！

结果：两个线程都执行了counter++，但counter只增加了1
*/

/**
 * 双重检查锁定（DCL）单例模式
 * 问题：存在指令重排序导致的线程安全问题
 */
public class Singleton {
    private static Singleton instance;

    public static Singleton getInstance() {
        if (instance == null) {                    // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) {            // 第二次检查
                    instance = new Singleton();    // 问题根源！
                }
            }
        }
        return instance;
    }
}

/*
问题分析：
instance = new Singleton() 分解为三步：

1. memory = allocate()    // 分配内存
2. ctorInstance(memory)   // 初始化对象
3. instance = memory      // 设置instance指向内存地址

指令重排序后可能变成：
1. memory = allocate()    // 分配内存
3. instance = memory      // 设置instance指向内存地址（提前！）
2. ctorInstance(memory)   // 初始化对象

并发问题：
时间  线程A                           线程B
t1   分配内存
t2   instance = memory（未初始化）
t3                                   if (instance == null) → false
t4                                   return instance  ← 返回未初始化的对象！
t5   初始化对象

结果：线程B拿到了一个未初始化的对象，使用时会出错

解决方案1：使用volatile禁止重排序
private static volatile Singleton instance;

解决方案2：使用静态内部类（推荐）
private static class SingletonHolder {
    private static final Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance() {
    return SingletonHolder.INSTANCE;
}
*/

/**
 * 规则1：程序顺序规则（Program Order Rule）
 * 一个线程内，代码的执行顺序，书写在前面的操作 happens-before 书写在后面的操作
 */
int a = 1;  // A
int b = 2;  // B
// A happens-before B
// 保证：B能看到A对a的写入

/**
 * 规则2：监视器锁规则（Monitor Lock Rule）
 * 对一个锁的解锁 happens-before 随后对这个锁的加锁
 */
synchronized (lock) {
    // A：释放锁之前的所有操作
    x = 1;
}  // 解锁

synchronized (lock) {
    // B：加锁之后的所有操作
    int y = x;  // 能看到 x = 1
}

/**
 * 规则3：volatile变量规则（Volatile Variable Rule）
 * 对一个volatile变量的写 happens-before 任意后续对这个volatile变量的读
 */
volatile boolean flag = false;

// 线程A
x = 1;              // 普通写
flag = true;        // volatile写

// 线程B
if (flag) {         // volatile读
    int y = x;      // 能看到 x = 1
}

/**
 * 规则4：传递性规则（Transitivity）
 * 如果 A happens-before B，B happens-before C，那么 A happens-before C
 */
x = 1;              // A
flag = true;        // B（volatile写）
if (flag) {         // C（volatile读）
    int y = x;      // A happens-before C，能看到 x = 1
}

/**
 * 规则5：线程启动规则（Thread Start Rule）
 * Thread.start() happens-before 该线程的每一个操作
 */
int x = 0;
Thread t = new Thread(() -> {
    int y = x;  // 能看到主线程对x的修改
});
x = 1;
t.start();  // start() happens-before 线程内的操作

/**
 * 规则6：线程终止规则（Thread Termination Rule）
 * 线程的所有操作 happens-before 其他线程检测到该线程终止
 * （通过Thread.join()或Thread.isAlive()）
 */
Thread t = new Thread(() -> {
    x = 1;  // 线程内操作
});
t.start();
t.join();  // 等待线程终止
int y = x;  // 能看到 x = 1

/**
 * 规则7：线程中断规则（Thread Interruption Rule）
 * 对线程interrupt()的调用 happens-before 被中断线程检测到中断事件
 */
Thread t = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        // 能检测到中断
    }
});
t.start();
t.interrupt();  // happens-before 线程内检测到中断

/**
 * 规则8：对象终结规则（Finalizer Rule）
 * 一个对象的初始化完成 happens-before 它的finalize()方法的开始
 */
// 保证对象构造完成后才能执行finalize()

/**
 * volatile的语义
 * 1. 可见性：对volatile变量的写，立即刷新到主内存；读，从主内存读取
 * 2. 有序性：禁止指令重排序
 */
public class VolatileSemantics {
    private int a = 0;
    private volatile boolean flag = false;

    // 线程A
    public void writer() {
        a = 1;              // 1
        flag = true;        // 2（volatile写）
    }

    // 线程B
    public void reader() {
        if (flag) {         // 3（volatile读）
            int i = a;      // 4
            // i一定等于1
        }
    }
}

/*
happens-before分析：
1. 程序顺序规则：1 happens-before 2
2. volatile规则：2 happens-before 3
3. 程序顺序规则：3 happens-before 4
4. 传递性：1 happens-before 4

结论：操作4能看到操作1的结果

禁止重排序的规则：
volatile写之前的操作 → 不能重排序到volatile写之后
volatile读之后的操作 → 不能重排序到volatile读之前
*/

/**
 * 场景1：状态标志
 * 最典型的用法
 */
public class StatusFlag {
    private volatile boolean shutdownRequested = false;

    public void shutdown() {
        shutdownRequested = true;
    }

    public void doWork() {
        while (!shutdownRequested) {
            // 做业务逻辑
        }
    }
}

/**
 * 场景2：DCL单例模式
 * 防止指令重排序导致的问题
 */
public class Singleton {
    private static volatile Singleton instance;

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

/**
 * 场景3：独立观察（发布-订阅）
 * 一个线程写，多个线程读
 */
public class CurrentTemperature {
    private volatile int temperature;

    public void update(int newTemp) {
        temperature = newTemp;  // 写线程
    }

    public int read() {
        return temperature;  // 读线程
    }
}

/**
 * 注意：volatile不能保证复合操作的原子性
 */
public class VolatileCounter {
    private volatile int count = 0;

    public void increment() {
        count++;  // 非原子操作！仍然有线程安全问题
    }

    // 正确做法1：使用synchronized
    public synchronized void incrementSafe1() {
        count++;
    }

    // 正确做法2：使用AtomicInteger
    private AtomicInteger count2 = new AtomicInteger(0);
    public void incrementSafe2() {
        count2.incrementAndGet();
    }
}

/**
 * final的内存语义
 * 1. 构造函数内对final字段的写入，与把this引用赋值给其他变量，不能重排序
 * 2. 初次读对象引用，与初次读该对象包含的final字段，不能重排序
 */
public class FinalFieldExample {
    final int x;
    int y;
    static FinalFieldExample obj;

    public FinalFieldExample() {
        x = 1;  // final字段的写入
        y = 2;  // 普通字段的写入
    }

    // 线程A
    public static void writerThread() {
        obj = new FinalFieldExample();
    }

    // 线程B
    public static void readerThread() {
        FinalFieldExample local = obj;  // 读对象引用
        if (local != null) {
            int a = local.x;  // 一定能看到 x = 1
            int b = local.y;  // 可能看到 y = 0（普通字段）
        }
    }
}

/*
final的保证：
1. 在构造函数内对final字段的写入，不会与构造函数外的对象引用赋值重排序
2. 一旦在构造函数内初始化final字段，其他线程就能看到final字段的值
3. 普通字段没有这个保证

错误示例（如果x不是final）：
可能的重排序：
obj = new FinalFieldExample();  // 对象引用赋值
x = 1;                          // 字段初始化

如果发生重排序，线程B可能看到 obj != null 但 x = 0
*/

/**
 * 问题版本：没有volatile
 */
public class Singleton {
    private static Singleton instance;  // 问题：没有volatile

    public static Singleton getInstance() {
        if (instance == null) {                    // 1. 第一次检查
            synchronized (Singleton.class) {       // 2. 加锁
                if (instance == null) {            // 3. 第二次检查
                    instance = new Singleton();    // 4. 创建对象
                }
            }
        }
        return instance;
    }
}

/*
深度剖析：为什么会出问题？

1. 对象创建的三个步骤：
   memory = allocate()    // 1. 分配内存
   ctorInstance(memory)   // 2. 初始化对象
   instance = memory      // 3. 设置instance指向内存

2. 可能的重排序：
   memory = allocate()    // 1. 分配内存
   instance = memory      // 3. 设置instance（提前！）
   ctorInstance(memory)   // 2. 初始化对象（延后！）

3. 并发问题：
   时间  线程A                           线程B
   t1   if (instance == null) → true
   t2   synchronized (Singleton.class)
   t3   if (instance == null) → true
   t4   memory = allocate()
   t5   instance = memory（未初始化）
   t6                                   if (instance == null) → false
   t7                                   return instance  ← 未初始化！
   t8   ctorInstance(memory)

4. 问题本质：
   线程B拿到的instance不为null，但指向的对象未完成初始化
   使用这个对象会导致不可预测的错误

5. 解决方案的对比：
*/

// 方案1：使用volatile（推荐）
public class Singleton {
    private static volatile Singleton instance;  // 加volatile

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                    // volatile禁止重排序，保证初始化完成后才赋值
                }
            }
        }
        return instance;
    }
}

// 方案2：静态内部类（最推荐）
public class Singleton {
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}
/*
优势：
1. 懒加载：只有调用getInstance()时才加载SingletonHolder
2. 线程安全：类加载机制保证初始化只执行一次
3. 无需同步：没有synchronized开销
4. 无需volatile：没有指令重排序问题
*/

// 方案3：枚举（最简洁）
public enum Singleton {
    INSTANCE;

    public void doSomething() {
        // 业务逻辑
    }
}
/*
优势：
1. 线程安全：枚举的实例创建是线程安全的
2. 防止反射攻击：枚举不能通过反射创建新实例
3. 防止反序列化攻击：枚举的反序列化会返回同一实例
4. 代码最简洁
*/

/**
 * 问题：SimpleDateFormat不是线程安全的
 */
public class DateFormatProblem {
    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 100; i++) {
            executor.submit(() -> {
                try {
                    String dateStr = "2024-01-15 12:30:00";
                    Date date = sdf.parse(dateStr);
                    System.out.println(date);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
    }
}

/*
执行结果（多次运行可能出现不同问题）：
1. java.lang.NumberFormatException
2. 解析出错误的日期
3. 偶尔正常

问题根源：
SimpleDateFormat内部使用Calendar对象，calendar字段是共享的
多线程并发调用parse()方法，会同时修改calendar，导致数据混乱

源码分析：
public Date parse(String source) throws ParseException {
    // calendar是成员变量，多线程共享
    calendar.clear();           // 清空日历
    calendar.set(...);          // 设置日期
    // 问题：线程A执行到一半，线程B清空了calendar
}

解决方案对比：
*/

// 方案1：每次创建新实例（浪费资源）
public class Solution1 {
    public Date parse(String dateStr) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.parse(dateStr);
    }
}

// 方案2：使用synchronized（性能差）
public class Solution2 {
    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public synchronized Date parse(String dateStr) throws ParseException {
        return sdf.parse(dateStr);
    }
}

// 方案3：使用ThreadLocal（推荐）
public class Solution3 {
    private static final ThreadLocal<SimpleDateFormat> threadLocal = ThreadLocal.withInitial(
        () -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
    );

    public Date parse(String dateStr) throws ParseException {
        return threadLocal.get().parse(dateStr);
    }
}

// 方案4：使用DateTimeFormatter（JDK 8+，最推荐）
public class Solution4 {
    private static final DateTimeFormatter formatter =
        DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    public LocalDateTime parse(String dateStr) {
        return LocalDateTime.parse(dateStr, formatter);
    }
}
/*
优势：
1. 线程安全：DateTimeFormatter是不可变类
2. 性能好：无需同步，无需创建新实例
3. API更友好：新的时间API更好用
*/