并发编程(volatile)

ゝ一纸荒年。 2022-03-21 14:15 316阅读 0赞

##### 并发编程中的三个概念 #####

###### 原子性 ######

`即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行`

###### 可见性 ######

`指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值`

###### 有序性 ######

`即程序执行的顺序按照代码的先后顺序执行(JVM在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗？不一定，为什么呢？这里可能会发生指令重排序)`

##### volatile关键字 #####

`修饰类的成员变量、类的静态成员变量，被volatile修饰之后，那么就具备了两层语义 1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的 2）禁止进行指令重排序`

###### volatile能保证对变量的操作是原子性吗 ######

public class Volatile02 {
        public volatile  int inc = 0;
        public void increase() {
            inc++;
        }
        public static void main(String[] args) {
            final Volatile02 test = new Volatile02();
            for (int i = 0; i < 20; i++) {
                new Thread(() -> {
                    for (int j = 0; j < 1000; j++) {
                        test.increase();
                        System.out.println("打印" + test.inc);
                    }
                }).start();
            }
        }
    }

打印10009
    打印10010
    打印10011
    打印9831
    打印10013
    打印10014
    打印10015

改为

public class Volatile02 {   
        Lock lock = new ReentrantLock();--或者
        public volatile  int inc = 0;
        public synchronized void increase() {
           lock.lock();
             try {
                inc++;
            } finally{
                lock.unlock();
            }
        }
        public static void main(String[] args) {
            final Volatile02 test = new Volatile02();
            for (int i = 0; i < 20; i++) {
                new Thread(() -> {
                    for (int j = 0; j < 1000; j++) {
                        test.increase();
                        System.out.println("打印" + test.inc);
                    }
                }).start();
            }
        }
    }

###### 使用场景 ######

`1）对变量的写操作不依赖于当前值2）该变量没有包含在具有其他变量的不变式中---上面的2个条件需要保证操作是原子性操作`

###### 在看一个单例模式 ######

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;
        }
    }

`对于Singleton这个变量为什么使用volatile修饰，因为new Singleton这个操作并不是原子的，它实际上执行了以下几个操作 1、给instance 分配内存 2、调用Singleton的init方法，实现参数的构建操作 3、将instance执向分配的内存 对于上面的操作，其执行顺序有可能是1-2-3，也有可能是1-3-2，如果是1-3-2，instance的值不为null，但是init方法还没有执行完，其他的线程在调用时，发现不为null, 直接返回，那就就会抛出异常`