Java教程

多线程—Java内存模型

本文主要是介绍多线程—Java内存模型,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

Java内存模型,JMM(Java Memory Model)。

概念:Java内存模型定义了final、volatile和synchronized关键字的行为并确保正确同步的Java程序能够正确运行在不同架构的处理器上。

作用:主要解决三个方面的问题

  1. 原子性问题

  2. 可见性问题

  3. 有序性问题

分析:

  1. 原子性:保证指令不会受到线程上下文切换的影响。

    理解:

    【原子】:字面意思是不可分割的意思,如果一个线程访问共享变量的操作,在其它线程看来是不可分割的,那么该操作就是原子操作,这个操作就具有原子性。

    【不可分割】:当一个线程访问共享变量的操作,在其他线程看来,这个操作要么执行结束,要么没有发生,其他线程无法看到该线程访问时的中间过程,讲到这里,是否让你联想到了MySQL数据库事务的原子性。另外,访问同一组共享变量的原子操作是不能够被交错的。

    注意:

    • 原子操作是针对访问共享变量的操作而言的。对于局部变量的访问,无所谓其是否是原子的。

    • 原子操作是从该操作线程以外的线程来描述的,所以,在多线程环境下才会有意义。

    实现原理:

    • 锁:锁具有排他性,它能保证一个共享变量在任意时刻只能被一个线程访问(竞态消除)。

    • CAS(Compare -and-Swap):它实现原子性的方式和锁实现原子性的方式实质上是一样的,差别在于,锁通常是在软件层面实现,而CAS直接在硬件(处理器和内存)层面实现,也就是俗称的”硬件锁“。

    常见的原子操作:

    基础类型中,除了long和double意外,其它基础类型变量的写操作都是原子操作。long和double类型变量的写操作,需要用到关键字volatile实现写的原子性。

    2、可见性

    概念:可见性就是指一个线程对共享变量的更新结果,对于读取相应共享变量的线程是否可见。

    实质:保证指令不受cpu缓存的影响。

    示例展示:

@Slf4j
public class TestOne {
    //创建一个标记
    static boolean run = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            //当标记为假 线程结束
            while(run){
				
            }
        },"t");
        t.start();
        sleep(1000);
        //更改标记 退出循环
        run = false;
        log.debug("标记已更改");
    }
}

运行结果展示:

虽然标记已经被更改了,但是线程还是一直在循环,没有结束。

接下来分析一下程序执行的过程:

分析之前大家应该要知道,Java内存模型把内存分为主存工作内存

  • 主存:存储共享信息的内存。

  • 工作内存:每个线程存储私有信息的内存。

  1. 初始状态:主内存存储共享变量run,t线程从主内存中读取run变量的值到工作内存。

 2. 示例代码的while循环中,t线程会不断的从主线程读取run的值,JIT编译器会将run变量的值缓存到自己工作内存的告诉缓存中,减少对主内存的访问,提升效率。

 3. 主线程sleep一秒之后,修改了run的值,并同步到主内存,但是t线程还是从自己的工作内存里面读取run的值,此时读取到的值没有得到更新,所以线程不会结束。

 

解决方式:

  1. 使用volatile关键字,使得t线程读取run变量时,就不会去自己的工作内存中读取,而是去主存中读取,run变量得到了即使的更新。

@Slf4j
public class TestOne {
    //创建一个标记,加上volatile关键字
    static volatile boolean run = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            //当标记为假 线程结束
            while(run){
				
            }
        },"t");
        t.start();
        sleep(1000);
        //更改标记 退出循环
        run = false;
        log.debug("标记已更改");
    }
}

2. 使用synchronized关键字,下面这段代码,如果去掉synchronized,那么线程将不会停止,而加上锁,就会实现volatile关键字一样的效果。

@Slf4j
public class TestOne {
    //创建一个标记,去掉了volatile
    static boolean run = true;
    //创建一个对象
    final static Object object = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(true) {
                synchronized (object) {
                    if (!run) {
                        break;
                    }
                }
            }
        },"t");
        t.start();
        sleep(1000);
        //更改标记 退出循环
        run = false;
        log.debug("标记已更改");
    }
}

两种解决方式比较:

  • 解决可见性问题使用volatile关键字更加轻量级一点,使用synchronized同步代码块代价更高,因为还要创建Monitor。

volatile的特点:

  • volatile只能保证变量的可见性,不能保证原子性。

  • synchronized既能保证代码块的原子性,也能保证代码块内变量的可见性,但是属于重量级操作,性能相对较低。

3、有序性

概念:有时一个处理器上运行的一个线程所执行的内存访问操作,在另外一个处理器上运行的其它线程看来是乱序的。

指令重排序:在源码顺序与程序顺序不一致,或者程序顺序与执行顺序不一致的情况下,就是发生了指令重排序。

解决指令重排序:创建变量时加上volatile关键字,在代码使用的时候,使用到该变量的代码行之前的代码无法进行指令重排序。

理解volatile保证可见性的原理:volatile底层实现原理是内存屏障。

  • 对volatile变量的写指令后会加入写屏障。

  • 对volatile变量的读指令前会加入读屏障。

    理解保证可见性的写/读屏障:

    • 写屏障保证在该屏障之前,对共享变量的改动,都同步到主存中,不仅是加了volatile关键字的共享变量,写屏障之前的所有共享变量。

    • 读屏障保证在该屏障之后,对共享变量的读取,加载的是主内存中的最新数据。

理解volatile保证有序性的原理:

理解保证可见性的写/读屏障:

  • 写屏障会保证指令重排序时,不会将写屏障之前的代码排在写屏障之后。

  • 读屏障会保证指令重排序时,不会将读屏障之后的代码排到读屏障之前。

注意:只能而解决本线程的指令重排,解决不了线程之间的指令重排。

这篇关于多线程—Java内存模型的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!