JUC之volatile

太过爱你忘了你带给我的痛 2021-12-24 06:25 220阅读 0赞

## 什么是JUC ##

juc就是java.util.concurrent（并发）包，rt.jar下面（runtime），  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_15_color_FFFFFF_t_70]  
一个包为何这么神奇？  
这个时候就引出了关键字volatile,

## 什么是volatile ##

volatile是java的一个关键字，百度一下，volatile所具有的三个特性：

*  可见性
 *  不具有原子性
 *  禁止指令重排

#### 可见性 ####

可见性：在A线程B线程同时访问变量X=1（存储在主内存）的时候，如果A把X的值修改为了2（A线程将主内存的X=1拷贝到自己线程的内存中进行修改，修改了之后在写回主内存），这个时候（主内存）会通知B线程X变成2了，举个栗子：上课签到，张三，李四，王五都要签到，再张三往花名册签完自己的名字之后，李四也能看到张三已经签过到了，王五也能看到，这样就不要帮张三代签了。

#### 原子性 ####

原子性：这个和我们事务的概念有点相似，就是某段代码整个是不可拆分的一部分，比如：

x++

这段代码表面上看上去只有一行，我们知道.java文件会编译成.class文件，从字节码中我们可以看出其实是分为两步的，回到我们的volatile，也就是说volatile并不能保证这两行中间没有执行其他代码。同样的，不保证原子性就是，再张三签到的时候，李四并不保证你张三有没有把自己的名字写好，再张三刚写了一个张的时候，李四就把笔抢过去写自己的名字了，这样就会有问题。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_16_color_FFFFFF_t_70]  
这边我们用一段代码来演示volatile不具备原子性。

package voliatile;
    
    public class VolatileTest {
    
        int number = 0;
    
        public void add() {
            number++;
        }
        public static void main(String[] args) {
            VolatileDemo volatileDemo = new VolatileDemo();
            for (int i = 0; i < 200; i++) {
                for (int j = 0; j < 1000; j++) {
                    new Thread(() -> {
                        volatileDemo.add();
                    }, String.valueOf(i)).start();
                }
            }
            while (Thread.activeCount() > 2) {
                Thread.yield();
            }
            System.out.println(volatileDemo.number);
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_16_color_FFFFFF_t_70 1]  
可以看到执行的结果并不是200000，为什么呢，前面说过了，再执行number++的时候是分两步的，可能这边的A线程执行到了第一步，得到number的值是100，同时B线程也拿到了number的值是100，然后两个线程同时加1，这个时候两个线程结束后，值是101，而不是102，那么怎么办呢，后面说。

#### 禁止指令重排（有序性） ####

在java文件变成class文件之后，jvm会对相互没有依赖性的不相关的语句进行优化，改变执行的顺序，比如:

String value ;
    boolean flag = fasle;
    public void test(){
    	value = get() ;   //1
    	flag = true ;     //2
    }
    
    public String get(){
    	if(flag){
    		reutrn "1";
    	}else{
    		return "2";
    	}
    }

这个时候在单线程下面可能这个程序是没问题的，但是在多线程下面，可能1 和 2 的顺序被执行成了2 1，这个时候下面的判断就会出问题了,这个时候需要volatile来修饰这个falg。至于禁止指令重排的原理就是再volatile关键字修饰的变量前后会加上storestore，或者loadload屏障，这两个指令是cpu的指令。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_16_color_FFFFFF_t_70 2]

**显然volatile的第一个和第三个特性是有助于并发编程的，问题是怎么保证原子性呢？**  
这个时候就引出了juc中的atomic（原子）包了，再atomic包中有好多atomic修饰的类，那么这些个atomic是怎么保证原子性的呢？下回分解。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_16_color_FFFFFF_t_70 3]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_15_color_FFFFFF_t_70]: /images/20211223/25fea6ba86864998a6a4bcef8077711e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_16_color_FFFFFF_t_70]: /images/20211223/ecd3bc98a46549a88de0c30339abb726.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_16_color_FFFFFF_t_70 1]: /images/20211223/2d42176cf9ef4b38a75e39652672aaf8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_16_color_FFFFFF_t_70 2]: /images/20211223/c79febd7c5454836bca2613f3751a39a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_16_color_FFFFFF_t_70 3]: /images/20211223/5597c9e15fe7493cb4833f8f8c99e3c6.png