Android 线程安全（一） volatile

╰+哭是因爲堅強的太久メ 2022-04-25 10:12 231阅读 0赞

### 目录 ###

*  volatile关键字
 *   *   *  1、可见性
         *  2、防止指令重排

# volatile关键字 #

### 1、可见性 ###

前提：变量保存在主存，如果线程修改变量要先将主存拷贝到线程缓存修改，之后再同步到主存。  
可见性：是指只能满足多线程写，读的时候，值正确。  
原理：  
1、volatile 声明的变量  
假设B线程缓存了主存的变量并修改（原子修改不是++这种非原子操作），线程A来读取主存的变量，jvm会强制将线程B的修改后变量同步到主存以后，再给A来用。多个线程写也是先等一个写完，同步到主存另一个开始写。  
2、不加volatile，  
假设B线程缓存了主存的变量并修改（原子修改不是++这种非原子操作），线程A来读取主存的变量，或得的是之前的值，并非是B修改后的值，这是不正确的。

使用场景线程中状态的改变等。例如如下代码

private volatile boolean isStop;
    
    
        private void testVisible(){
            //工作线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while (!isStop){
                        Log.i("qinxue","running");
                    }
                }
            }).start();
    
            //控制线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(2000);
                        isStop = true;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

3、非原子操作写例如++，看下面代码

private volatile int count = 0;
        private Object object = new Object();
        private void testVolatile() {
            for (int i = 0; i < 2000; i++) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            long sleepTime = (long) (Math.random() *60); //为了更容易出现竞争
                            Thread.sleep(sleepTime);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
    //                   添加synchronized互斥之后可以保证正确
    //                    synchronized (object){
    //                        count++;
    //                    }
                        count++;
                        Log.i("qinxue", "count: " + count);
                    }
                }).start();
            }
        }

前提：i++，包含3个步骤  
1，从内存读取i当前的值  
2，加1  
3，把修改后的值刷新到内存

结果count<=2000 即使添加了 volatile 关键字声明，由于++不是原子性的，1和3是原子性，在1和3之前还有操作，可能有线程一起做了。这样就少加了，所以是count<=2000.

控制线程修改 isStop，while判断是等修改完成后获取的。

### 2、防止指令重排 ###

jvm会优化一些指令，例如new 一个对象  
1.分配对象的内存空间。  
2.初始化对象。  
3.设置instance指向刚分配的内存地址。  
其中2和3可能被优化成3，2。

原理：  
1、未使用 volatile 声明 A线程 getInstance 在new Singleton()指令重排了，虽未初始化对象，但是instance！=null了， B线程获取到instance，这是肯定是用不了的。出现错误。  
2、使用 volatile 声明 A线程 getInstance 在new Singleton() 不会指令重排，B线程获取到instance时肯定是初始化完成的了，对B线程来说是可用的。  
最常见的是单例模式的一种写法

public class Singleton {
        private volatile static Singleton instance = null;
    
        private Singleton() {
        }
    
        public static Singleton getInstance() {
            if (instance == null) {
                synchronized (Singleton.class) {
                    if (instance == null) {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }