Java 并发编程的可见性、有序性和原子性

Java 并发编程的可见性、有序性和原子性是非常重要的概念和技能，在实际开发中必须掌握。本文将具体讲解这方面的知识。

可见性

所谓可见性，是指当多个线程同时访问共享变量时，一个线程修改了该变量的值，其他线程能够立即看到这个变化。在 Java 并发编程中，如果没有采取特殊的措施，共享变量的修改并不一定对所有线程都可见，这样就可能造成线程安全问题。

为了保证可见性，可以使用 volatile 关键字来定义变量。当一个变量被 volatile 修饰时，任何对该变量的读写操作都会直接从主存中进行，而不是从线程的工作内存中进行。因此，当一个线程修改了 volatile 变量的值时，其他线程能够立即看到这个变化。

示例1：使用 volatile 关键字保证可见性

public class MyThread extends Thread {
    private volatile boolean flag = false;

    @Override
    public void run() {
        while (!flag) {
            // do something
        }
        System.out.println("flag has changed to true");
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        myThread.start();
        Thread.sleep(1000);
        myThread.setFlag(true);
    }
}

在上述代码中，MyThread 类中定义了一个 volatile 变量 flag，并在其 run() 方法中不断地检测其值是否为 true。在 Main 类中，创建一个 MyThread 实例并启动，然后等待 1 秒钟，修改 flag 的值为 true。由于 flag 是 volatile 变量，因此在修改完之后，MyThread 线程能够立即看到 flag 的变化，从而退出 while 循环，执行 System.out.println 语句。

有序性

所谓有序性，是指程序执行时，如果两个操作存在数据依赖关系，JVM 会按照代码的顺序执行这两个操作，即保证这两个操作不会发生重排序。如果这两个操作不存在数据依赖关系，JVM 可以自由地对它们进行重排序，以达到优化的目的。

为了保证操作的有序性，可以使用 synchronized 关键字或者 Lock 接口来实现锁机制。当一个线程持有了一个锁时，其他线程必须等待这个锁被释放后才能继续执行，从而保证操作的有序性。

示例2：使用 synchronized 关键字保证有序性

public class Main {
    private static int count = 0;

    public static synchronized void increment() {
        count++;
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        });

        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();

        System.out.println("count = " + count);
    }
}

在上述代码中，Main 类中定义了一个静态 count 变量和一个 increment() 方法，在这个方法中对 count 变量进行自增。使用 synchronized 关键字修饰 increment() 方法，保证在一个线程持有锁时，另一个线程无法进入这个方法，从而保证了操作的有序性。

执行 Main 类的 main() 方法时，启动两个线程分别执行 increment() 方法 1000 次，最终输出 count 变量的值。由于 increment() 方法被 synchronized 关键字修饰，因此对 count 变量的修改一定是有序的，不会造成线程安全问题。