关于Java内存模型的三个特性

Java在面对跨平台问题时，重要的一项就是解决硬件和操作系统内存之间的访问。

简要工作逻辑如下图：

image

• cpu的处理速度远快于内存的读写速度，因此Java采用高速缓存建立其桥梁。

• 其中protocal协议是为了保证多个进程访问cpu主内存时，多个缓存与主内存数据一致性。

• 当线程需要使用变量数据时，需要从主内存中拷贝一个副本到自己的缓存中，线程来操作这个副本数据，这个缓存也被称作工作内存。

• 线程修改完数据后重新写入主内存，并更新数据。

image

思考：多个线程修改主内存的同一个数据，t1在操作备份数据时，别的线程能否中断或挂起t1的执行？t1先写入主内存后，t2,t3中的备份数据怎么办？同一线程中，操作顺序是固定的吗？

内存模型的三大特性

1、原子性

---

原子性即指在一个操作中，不能被其他操作中断，类似数据库事务的原子性，一个操作就是一个原子操作，保证了线程的安全和数据可靠。

Java 内存模型定义了 8 个操作来完成主内存和工作内存的交互操作，如上图2。他们的操作就是原子性的。

需要注意的是，没有被volatile修饰的64位数据，会被分2次32位操作，操作一半时可能被其他线程读取，造成结果错误。

示例：1000 个线程同时对num 执行自增操作的结果。

class MyData{
    private int num = 0;

    public void add(){
        num++;
    }

    public int getNum() {
        return num;
    }
}
public class Test04 {
    public static void main(String[] args) throws InterruptedException {
        final int totalNum = 1000;
        MyData myData = new MyData();
        CountDownLatch count = new CountDownLatch(totalNum);
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < totalNum; i++) {
            executor.execute(() -> {
                myData.add();
                count.countDown();
            });
        }
        count.await();
        executor.shutdown();
        System.out.println(myData.getNum());
    }
}

980

结果为：980<1000，数据不安全。如一个线程执行自增过程中，另一个线程也执行了自增，两个线程同时写入了主内存。解决办法如下

1.1 原子类(Atomic)

使用AtomicInteger类型可以保证多线程下执行的原子性。

修改原来的代码，将num改为AtomicInteger类型数据。

class MyData{
    private AtomicInteger num = new AtomicInteger();

    public void add(){
        num.incrementAndGet();
    }

    public int getNum() {
        return num.get();
    }
}
...

1000

1.2 互斥锁(synchronized)

当然，解决线程访问冲突问题，同步锁永远是最直接的方法。但阻塞比较消耗性能，非必要不推荐。

2、可见性

---

先看代码：

class MyData2{
    volatile int num2 = 0;

    public void addTo60(){
        this.num2 = 100;
    }
}

public class Test02 {
    public static void main(String[] args) {
        MyData2 myData = new MyData2();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+" --- 原数据 = "+myData.num2);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myData.addTo60();
            System.out.println(Thread.currentThread().getName()+" --- 修改后数据 = "+myData.num2);
        },"myThread01").start();

        while (myData.num2 == 0){
            // 当num修改时，等待结束
        }

        System.out.println(Thread.currentThread().getName()+" --- 主线程 = "+myData.num2);
    }
}

运行效果图：

image

线程一直处于阻塞状态，卡在while中，而myThread01打印出num=60。这是因为，myThread01在修改前，主线程已进入while(1)循环，num改变后主线并不知道数据已经被修改。由此引入可见性的概念。

2.1 可见性

当一个线程修改了共享变量的值，其它线程能够立即得知这个修改。

Java 内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值来实现可见性的。

2.2 实现方式

• volatile
• synchronized
• final，前提：不发生this逃逸。深入理解Java中的逃逸分析

上述代码中，只需将num2类型加volatile即可实现可见性。

volatile int num2 = 0;

myThread01 --- 原数据 = 0
myThread01 --- 修改后数据 = 100
main --- 主线程 = 100

3、有序性

---

有序性是指在本线程内观察，所有操作都是有序的。在一个线程观察另一个线程，所有操作都是无序的。

无序的因为是指令重排序，编译器的一种优化方式。单线程条件下可以提高代码效率，保证了最终执行结果个代码执行顺序的执行结果一直。但却会影响到多线程并发执行的正确性。

重排序是需考虑到数据之间的依赖性。

3.1 解决方式

• volatile
• synchronized