欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

JMM入门学习

程序员文章站 2023-12-03 10:51:34
JMM学习学习资料:b站诸葛老师-JMM篇一、系统CPU和主内存交互图:二、JMM模型Java线程内存模型跟cpu缓存模型类似,是基于cpu缓存模型来建立的,java线程内存模型是标准化的,屏蔽掉了底层不同计算机的区别注意:每个线程操作共享变量操作的是复制主内存的副本,当一个线程修改了自己工作内存中变量,对其他线程是不可见的,会导致线程不安全的问题。下面代码演示这种问题:代码测试:package com.lxf.volatileT;import java.util.concurre...

JMM学习

学习资料:

b站诸葛老师-JMM篇

一、系统CPU和主内存交互图:

JMM入门学习

二、JMM模型

Java线程内存模型跟cpu缓存模型类似,是基于cpu缓存模型来建立的,java线程内存模型是标准化的,屏蔽掉了底层不同计算机的区别

JMM入门学习

JMM入门学习

注意:每个线程操作共享变量操作的是复制主内存的副本,当一个线程修改了自己工作内存中变量,对其他线程是不可见的,会导致线程不安全的问题。下面代码演示这种问题:

代码测试:

package com.lxf.volatileT;

import java.util.concurrent.TimeUnit;

/**
 * 两个线程访问同一个共享变量,一个线程修改完共享变量后,另一个线程对这个共享变量是不可见的
 */
public class JMMDemo {
    private  static   boolean flag=true;

    public static  void main(String[] args) {

        new Thread(()->{//线程1
            while (flag){

            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        flag=false;
        System.out.println("flag="+flag);
    }
}

结果:打印flag=true,但是线程1并未停止

解决方法:

package com.lxf.volatileT;

import java.util.concurrent.TimeUnit;

/**
 * volatile实现实现之间共享变量可见
 *volatile作用:线程之间可见、有序性(防止指令重排)、不能保证原子性
 */
public class JMMDemo {
    private  static volatile  boolean flag=true;

    public static  void main(String[] args) {

        new Thread(()->{//线程1
            while (flag){

            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        flag=false;
        System.out.println("flag="+flag);
    }
}

在打印flag=true之后,线程1也停止了

三、JMM数据原子操作、volatile原理、volatile特性

3.1、JMM数据原子操作
  1. read(读取):从主内存读取数据
  2. load(载入):将主内存读取到的数据写入工作内存
  3. use(使用):从工作内存读取到的数据来计算
  4. assign(赋值):将计算好的值重新赋值到工作内存中
  5. store(存储):将工作内存数据写入主内存
  6. write(写入):将sotre过去的变量值赋值给主内存中的变量
  7. lock(锁定):将主内存变量加锁,标识为线程独占状态
  8. unlock(解锁):将主内存变量解锁,解锁后其它线程可以锁定该变量
3.2、JMM对这八种指令的使用,制定了如下规则:
  1. 不允许read和load、store和write操作之一单独出现。即使用了read必须load,使用了store必须write

  2. 不允许线程丢弃他最近的assign操作,即工作变量的数据改变了之后,必须告知主存

  3. 不允许一个线程将没有assign的数据从工作内存同步回主内存

  4. 一个新的变量必须在主内存中诞生,不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前,必须经过assign和load操作

  5. 一个变量同一时间只有一个线程能对其进行lock。多次lock后,必须执行相同次数的unlock才能解锁。

  6. 如果对一个变量进行lock操作,会清空所有工作内存中此变量的值,在执行引擎使用这个变量前,必须重新load或assign操作初始化变量的值

  7. 如果一个变量没有被lock,就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量。

  8. 对一个变量进行unlock操作之前,必须把此变量同步回主内存

3.3、查看底层汇编指令
  1. 下载显示汇编代码的插件放入jdk中
  2. java程序汇编代码查看:-server -Xcomp -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -XX:CompileCommand=compileonly,*VolatileVisbilityTest.prepareData
3.4、根据汇编代码探究Volatile缓存可见性实现原理
  • 底层实现主要是通过汇编lock前缀指令,它会锁定这块内存区域的缓存(缓存行锁定)并回写到主内存。
  • IA-32架构软件开发者手册对lock指令的解释:
    • 会将当前处理器缓存行的数据立即写回到系统内存。
    • 这个写回内存的操作会引起在其他CPU里缓存了该内存地址的数据无效(MESI协议)

JMM入门学习

3.5、volatile的特性
  • 首先我们要知道并发编程的三大特性:可见性、原子性、有序性
  • Volatile保证可见性与有序性,但是不保证原子性,保证原子性需要借助synchronized、lock这样的锁机制

Volatile不保证原子性代码测试:

package com.lxf.jmm;


public class VolatileAtomicTest{
    public static volatile int num=0;

   public static void increase(){
       num++;
   }

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads=new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            threads[i]=new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    increase();
                }
            });
            threads[i].start();
        }
        //等所有线程执行完了再执行main
        for (Thread thread : threads) {
            thread.join();
        }

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

结果是<=10000,多次运行就能看到。

分析原因:

num++是一组操作(假设num值初始值为0),里面分为三步原子操作:读取到num值,num值加1,将num值写回缓存,这三步操作都有可能阻塞。假如一个线程读取num值后阻塞,然后另一个线程执行完了:将num赋值为1,然后这个线程继续执行将值仍然返回为1,这就造成了上面的问题。

参考博文:volatile为什么不能保证原子性

Volatile保证有序性测试(禁止指令重排)

package com.lxf.jmm;

import java.util.HashMap;
import java.util.Map;

public class VolatileSerialTest {
    static int x=0,y=0;

    public static void main(String[] args) throws InterruptedException {
        //存结果的Map集合
        Map<String,Integer> resultMap=new HashMap<>();

        for (int i = 0; i < 1000000; i++) {
            x=0;y=0;
            resultMap.clear();
            //第一个线程
            Thread one=new Thread(()->{
                int a=y;
                x=1;
                resultMap.put("a",a);
            });
            //第二个线程
            Thread two=new Thread(()->{
                int b=x;
                y=1;
                resultMap.put("b",b);
            });
            //第一个线程开启
            one.start();
            //第二个线程开启
            two.start();
            //第一个线程插队
            one.join();
            //第二个线程插队
            two.join();

            if(resultMap.get("a")==0&&resultMap.get("b")==0){
                System.out.println("===============a等于0,b也等于0================================");
                System.out.println("a=" + resultMap.get("a") + ",b=" + resultMap.get("b"));
                System.out.println("===============a等于0,b也等于0================================");
            }else if(resultMap.get("a")==1&&resultMap.get("b")==1){
                System.out.println("===============a等于1,b也等于1================================");
                System.out.println("a=" + resultMap.get("a") + ",b=" + resultMap.get("b"));
                System.out.println("===============a等于1,b也等于1================================");
            }else{
                System.out.println("a=" + resultMap.get("a") + ",b=" + resultMap.get("b"));
            }

        }
    }
}

结果可能性:

a=0,b=0

a=0,b=1

a=1,b=0

a=1,b=1

结果分析:前三个可能性我们都知道,当one线程在前结果就是a=1,b=0,当two线程在前结果就是a=0,b=1,当两个线程同时运行:a=0,b=0。但是a=1,b=1这种可能性还是难以理解,但还是存在的(很少见,得大量运行)见下图:

JMM入门学习

因为发生了指令重排序:

JMM入门学习

解决方法:定义x,y的时候加上volatile关键字就可以解决了

具体解释看以下博文:

参考博文:
1. 并发关键字volatile(重排序和内存屏障)

2.Volatile禁止指令重排

本文地址:https://blog.csdn.net/Inmaturity_7/article/details/107086864