Java多线程三大特性之原子性、可见性、有序性详解

public class SynchronizedExample {
    private int count = 0;

    public synchronized void increment() {
        count++; // 非原子操作，需同步保护
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedExample e = new SynchronizedExample();
        Thread t1 = new Thread(() -> { for (int i = 0; i < 1000; i++) e.increment(); });
        Thread t2 = new Thread(() -> { for (int i = 0; i < 1000; i++) e.increment(); });
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println("Final count: " + e.count); // 输出 2000
    }
}

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock(); // 必须在 finally 中释放
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLockExample e = new ReentrantLockExample();
        Thread t1 = new Thread(() -> { for (int i = 0; i < 1000; i++) e.increment(); });
        Thread t2 = new Thread(() -> { for (int i = 0; i < 1000; i++) e.increment(); });
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println("Final count: " + e.count); // 输出 2000
    }
}

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet(); // 原子自增
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicExample e = new AtomicExample();
        Thread t1 = new Thread(() -> { for (int i = 0; i < 1000; i++) e.increment(); });
        Thread t2 = new Thread(() -> { for (int i = 0; i < 1000; i++) e.increment(); });
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println("Final count: " + e.count.get()); // 输出 2000
    }
}

import java.util.concurrent.locks.StampedLock;

public class StampedLockExample {
    private double x = 0, y = 0;
    private final StampedLock sl = new StampedLock();

    void move(double dx, double dy) {
        long stamp = sl.writeLock();
        try {
            x += dx;
            y += dy;
        } finally {
            sl.unlockWrite(stamp);
        }
    }

    double distanceFromOrigin() {
        long stamp = sl.tryOptimisticRead(); // 乐观读
        double currentX = x, currentY = y;
        if (!sl.validate(stamp)) { // 检查是否被写入
            stamp = sl.readLock(); // 升级为悲观读
            try {
                currentX = x;
                currentY = y;
            } finally {
                sl.unlockRead(stamp);
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }

    public static void main(String[] args) {
        StampedLockExample obj = new StampedLockExample();
        obj.move(3, 4);
        System.out.println("Distance: " + obj.distanceFromOrigin()); // 输出 5.0
    }
}

public class VolatileVisibilityExample {
    private volatile boolean running = true; // volatile 保证可见性

    public void stop() {
        running = false;
    }

    public void runTask() {
        while (running) {
            System.out.println("Working...");
            try { Thread.sleep(500); } catch (InterruptedException e) { break; }
        }
        System.out.println("Task stopped.");
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileVisibilityExample task = new VolatileVisibilityExample();
        Thread worker = new Thread(task::runTask);
        worker.start();
        Thread.sleep(2000);
        task.stop(); // 主线程停止任务
        worker.join();
    }
}

public class FinalFieldExample {
    private final int x;
    private final int y;

    public FinalFieldExample(int x, int y) {
        this.x = x;
        this.y = y; // 构造完成后对所有线程可见
    }

    public int sum() {
        return x + y; // 无需同步，安全
    }

    public static void main(String[] args) {
        FinalFieldExample obj = new FinalFieldExample(3, 4);
        new Thread(() -> {
            System.out.println("Sum in thread: " + obj.sum()); // 输出 7
        }).start();
    }
}

public class DoubleCheckedLockingSingleton {
    // 必须加 volatile！否则可能返回未完全初始化的对象
    private volatile static DoubleCheckedLockingSingleton instance;

    private DoubleCheckedLockingSingleton() {}

    public static DoubleCheckedLockingSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedLockingSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton(); // 关键：防止重排序
                }
            }
        }
        return instance;
    }

    public void doSomething() {
        System.out.println("Singleton working...");
    }

    public static void main(String[] args) {
        DoubleCheckedLockingSingleton s1 = getInstance();
        DoubleCheckedLockingSingleton s2 = getInstance();
        System.out.println(s1 == s2); // true
        s1.doSomething();
    }
}