[Java知识库] Volatile关键字的简单学习总结

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> Volatile关键字的简单学习总结 -> 正文阅读

[Java知识库]Volatile关键字的简单学习总结

首先，先了解一下JMM

什么是JMM：即java内存模型，是一种概念约定。

关于JMM的一些同步的约定：

线程解锁前，必须把共享变量立刻刷回主存。
线程加锁前，必须读取主存中的最新值到工作内存中。
加锁和解锁是同一把锁。

先来看看八种内存交互操作：

根据上图，有了个问题：线程A中拿到主存中的值，做了修改之后，B线程能否知道线程A干的这件事，并且将修改的值响应给B线程？? ?

对于上面的这个问题，其实就是java并发编程中的可见性问题！

而可见性就是靠JMM内存模型来解实现的。

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操作之前，必须把此变量同步回主内存。

?言归正传，现在来看看Volatile关键字

Volatile是java虚拟机提供轻量级的同步机制，他有如下特点： 保证可见性、不保证原子性、禁止指令重排。

1.保证可见性??

保证可见性是与JMM相关的。

例子：

public class JMMdemo1 {
    private volatile static  int num=0;
    public static void main(String[] args) {  

        new Thread(()->{     
        while (num==0){
            System.out.println(num);
        }
        }).start();


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

        num=1;
        System.out.println(num);
    }
}

运行结果：

2.不保证原子性

原子性：不可分割，线程a执行的时候，不能被打扰，也不能被分割；要么同时成功，要么同时失败


public class JMMdemo2 {
    private volatile static int num=0;
    public static void add(){
       num++;      
    }

    public static void main(String[] args) {
        //创20个线程，每个线程做1000次add()
        for (int i = 0; i < 20; i++) {

            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();

         while(Thread.activeCount()>1) {   //保证前面的线程都执行完
                  Thread.yield();
               } 
           
        }

        System.out.println(Thread.currentThread().getName()+" "+num);
    }
}

运行结果：? main 11848? ? 每次都不一样，但都不是预想的20000

如何能实现原子性呢？

1.synchronized

2.lock

3.使用原子类( AtomicInteger)

以上3种方式的具体例子就不一一举例了，可以自行尝试。