关于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 实现方式

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

volatile int num2 = 0;
复制代码
myThread01 --- 原数据 = 0
myThread01 --- 修改后数据 = 100
main --- 主线程 = 100
复制代码

3、有序性


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

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

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

3.1 解决方式

  • volatile
  • synchronized

猜你喜欢

转载自juejin.im/post/5cb5d419e51d456e500f7d02
0条评论
添加一条新回复