Java并发08：并发编程的三大核心问题 - 原子性、可见性、有序性

// volatile只解决部分问题
private volatile int count = 0;
count++;  // 仍然不安全！

// synchronized解决所有问题
private int count = 0;
public synchronized void increment() {
    count++;  // 安全
}

int a = 10;     // ✅ 原子操作
a++;            // ❌ 非原子操作（3条指令）

// ✅ 基本类型的读写（long/double除外）
int a = 1;
boolean b = true;

// ✅ 引用类型的读写
Object obj = new Object();

// ✅ volatile变量的读写
volatile int count = 0;
count = 1;  // 原子的

// ❌ long/double（64位，需要两次操作）
long value = 123L;  // 非原子的（未加volatile）

// ❌ 复合操作
count++;            // read-modify-write
array[index]++;     // 非原子

// ❌ check-then-act
if (map.get(key) == null) {
    map.put(key, value);  // 竞态条件
}

public synchronized void increment() {
    count++;  // 整个方法是原子的
}

private Lock lock = new ReentrantLock();

public void increment() {
    lock.lock();
    try {
        count++;
    } finally {
        lock.unlock();
    }
}

private AtomicInteger count = new AtomicInteger(0);

public void increment() {
    count.incrementAndGet();  // 原子操作
}

public class VisibilityDemo {
    private boolean ready = false;  // ← 无volatile
    private int number = 0;
    
    // 线程1：写入
    public void writer() {
        number = 42;
        ready = true;  // ← 线程2可能看不到
    }
    
    // 线程2：读取
    public void reader() {
        while (!ready) {  // ← 可能永远循环
            Thread.yield();
        }
        System.out.println(number);  // 可能输出0
    }
}

private volatile boolean ready = false;  // ← 保证可见性

public void writer() {
    number = 42;
    ready = true;  // ← 立即刷新到主内存
}

public void reader() {
    while (!ready) {  // ← 立即从主内存读取
        Thread.yield();
    }
    System.out.println(number);  // 一定输出42
}

private boolean ready = false;

public synchronized void writer() {
    ready = true;  // 退出synchronized时刷新
}

public synchronized boolean isReady() {
    return ready;  // 进入synchronized时读取最新值
}

public class Holder {
    private final int value;
    
    public Holder(int value) {
        this.value = value;
    }
    // 构造函数完成后，value对所有线程可见
}

// 原始代码
int a = 1;  // 语句1
int b = 2;  // 语句2
int c = a + b;  // 语句3

// 可能重排序为：
int b = 2;  // 语句2
int a = 1;  // 语句1
int c = a + b;  // 语句3

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();

private static volatile Singleton instance;  // ← 禁止重排序

public static Singleton getInstance() {
    if (instance == null) {
        synchronized (Singleton.class) {
            if (instance == null) {
                instance = new Singleton();  // 不会重排序
            }
        }
    }
    return instance;
}

// synchronized块内的代码不会与块外的代码重排序

// ✅ volatile：状态标志
private volatile boolean shutdown = false;

public void shutdown() {
    shutdown = true;  // 仅需可见性
}

// ❌ volatile：count++（需要原子性）
private volatile int count = 0;
count++;  // 不安全！

// ✅ synchronized：count++（需要原子性）
private int count = 0;
public synchronized void increment() {
    count++;  // 安全
}

// ✅ AtomicInteger：count++（高性能）
private AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet();  // 安全且高效

// 程序顺序规则
int a = 1;  // 操作1
int b = a + 1;  // 操作2，能看到a=1

// volatile规则
volatile boolean ready = false;
number = 42;      // 操作1
ready = true;     // 操作2（volatile写）
// 操作1 happens-before 操作2
// 其他线程读到ready=true时，一定能看到number=42

// 场景1：状态标志（只需可见性）
private volatile boolean running = true;

// 场景2：计数器（需要原子性）
private AtomicInteger count = new AtomicInteger(0);

// 场景3：复杂操作（需要所有保证）
public synchronized void transfer(int amount) {
    balance -= amount;
    otherAccount.balance += amount;
}

// 场景4：双重检查锁定（需要可见性+有序性）
private static volatile Singleton instance;