转载

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

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

简要工作逻辑如下图：

cpu的处理速度远快于内存的读写速度，因此Java采用 高速缓存 建立其桥梁。
其中protocal协议是为了保证多个进程访问cpu主内存时，多个缓存与主内存数据一致性。
当线程需要使用变量数据时，需要从主内存中拷贝一个副本到自己的缓存中，线程来操作这个副本数据，这个缓存也被称作 工作内存 。
线程修改完数据后重新写入主内存，并更新数据。

思考：多个线程修改主内存的同一个数据，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);
    }
}
复制代码

运行效果图：

线程一直处于阻塞状态，卡在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

原文 https://juejin.im/post/5cb5d419e51d456e500f7d02

正文到此结束

所属分类： Java 编程技术

本文标签： UI volatile Service 原子类 https 安全重排序 Atom synchronized 协议 cat Java内存模型 ACE 一致性编译进程操作系统 http 模型备份线程代码 src id java 数据库内存模型同步 IO 并发多线程 final executor 缓存 tar 数据锁 cache CountDownLatch
版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
本文海报： 生成海报一生成海报二

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

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

内存模型的三大特性

1、原子性

1.1 原子类(Atomic)

1.2 互斥锁(synchronized)

2、可见性

2.1 可见性

2.2 实现方式

3、有序性

3.1 解决方式

热门推荐

相关文章

说给你听

本文目录

随机标签

书籍教程

近期评论

网站信息

其他链接

关于本站

问题交流