volatile关键字多线程

最近在看多线程.

volatile关键字网上好多文章对这个关键字的解释都有错，很难受。

volatile关键字是多线程中很重要的知识点，volatile关键字可以保证可见性，不能保证原子性，重点不能保证原子性，网上还有说什么保证弱原子性，还来个弱原子性，扯犊子，不够乱还来个弱原子性。volatile没有原子性，不能保证原子性！！！

多个线程在运行的时候，每个线程都有自己的一部分缓存，也有线程公共区域的内存，假如线程1在运行中会把公共区域部分的数据缓存到自己的缓存部分，这个时候线程2更改公共区域部分的数据后，导致线程1中的内容和公共区域的数据不一致，这个很尴尬了，volatile关键字就保证了，公共区域的数据每次被修改后，都会通知其他线程，你的缓存中的被volatile关键字修饰的部分无效了。

接下来用程序来证明它的可见性、证明他没有原子性。

先证明可见性吧，如何证明呢？

让公共资源中的boolean类型的run初始是true，然后如果是true则线程一运行起来，然后再用另外一个线程将run设为false，看线程一是否还在运行，如果还在运行证明线程一就根本没有感觉到run值的更改，用的依旧是自己线程独占区的run的缓存值，不具有可见性。如果线程停止了则说明线程一用的就是线程共享区的数据，程序属于正常行为，存在可见性。

 

程序设计如下。  

package thread.mashibing.student1;

/**
 * @Description:
 * @Date: 2019/7/18
 * @Author tongtongdi
 * qq:729728698
 * @Version 1.0
 */

public class volatileTest {

    //初始状态为true
    //boolean run = true;
    volatile boolean run = true;

    //线程中的方法
    void showStart(){
        System.out.println("showStart is running.....");
        while (run){

        }
        System.out.println("showStart is ending....");
    }


    public static void main(String[] args) throws InterruptedException {
        volatileTest volatileTest = new volatileTest();
        //线程一启动
        new Thread(()->{
            volatileTest.showStart();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        //主线程休眠一秒
        Thread.sleep(1000);

        //线程二启动
        new Thread(()->{
            volatileTest.run = false;
        }).start();
    }
}

给boolean run = true;前面不加volatile,运行一哈试一哈。

一直是这个样子，线程一一直在运行，线程二更改后线程一还在运行，傻孩子数据都变了，你还拿的是去年老师给你的考试大纲。

加上volatile之后，

run被更改后，通知其他线程，你们的run缓存数据无效了，无效了，来爸爸这拿最新的，好正常运行了。

然后证明这个volatile没有原子性，原子性是个具体什么意思，就是我改这个值的时候，整个操作是一个整体，就是改的时候别的线程等我改完之后再读，再给你最新的。

我们同时运行十个线程来给线程公共区的数据count = 0;进行++操作，每个线程加100000个，如果正常结束应该就是1000000。如果不具有原子性则多少就不一定了，上代码。

package thread.volatileMainTest;

import java.util.ArrayList;
import java.util.List;

/**
 * @Description:
 * @Date: 2019/7/19
 * @Author tongtongdi
 * @Version 1.0
 */

public class VolatileTest {

    //运行开关
    private volatile int count = 0;

    void m(){
        for(int i=0;i<100000;i++){
            count++;
        }
    }
    public static void main(String[] args) {

        //创建一个对象
        VolatileTest vt = new VolatileTest();
        //定义一个线程list
        List<Thread> threads = new ArrayList<>();
        //初始化线程
        for(int i=0;i<10;i++){
            threads.add(new Thread(()->{
                vt.m();
            },"thread"+i));
        }
        //线程启动
        threads.forEach((o)->{
            o.start();
        });
        //子线程执行主线程等待
        threads.forEach((o)->{
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(vt.count);



    }

}

 

      程序中用了花里胡哨的lambda表达式，java8新加的东西，可以学习下，就程序更简洁，更高大上点吧。执行这个代码你会发现这个结果并不是想要的1000000，而是要小很多，这就是没有原子性，加了volatile和去掉volatile是一样的，因此不能保证原子性。改成synchronized方法就可以实现了。

volatile还有禁止重排序的作用，就是有序性。最典型的就是双重锁的概念了。

public class SecondSingleton {
    //volatile关键字保证可见性 同时禁用指令重排（jdk1.5后生效）
    private static volatile SecondSingleton singleton;
    
    private SecondSingleton(){
        
    }
    
    /**
     * 双重检查锁实现单例模式
     * 推荐这样写，既保证线程安全，又延迟加载
     * @return
     */
    public static SecondSingleton getSingleton() {
        if (singleton == null) {
            synchronized (SecondSingleton.class) {
                if(singleton == null){
                    singleton = new SecondSingleton();
                }
            }
        }
        return singleton;
    }
}

 

主要在于singleton = new SecondSingleton();这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情:

1. 给 singleton 分配内存
2. 调用 SecondSingleton的构造函数来初始化成员变量
3. 将singleton 对象指向分配的内存空间（执行完这步 singleton 就为非 null 了）

但是由于指令重排，上述第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1->2->3 也可能是 1->3->2。如果是后者，则在 3 执行完毕，2 未执行之前，另一个线程执行if (singleton == null) ，这时 singleton 已经是非 null 了，但却没有初始化，所以该线程会直接返回 singleton ，然后使用，自然就会报错了。