volatile关键字的作用以及单例模式(饿汉模式与懒汉模式的区别及改进)

2024-03-08 7986阅读

文章目录

💡volatile保证内存可见性
💡单例模式
💡饿汉模式
💡懒汉模式
💡懒汉模式多线程版
💡volatile防��指令重排序
💡volatile保证内存可见性

Volatile 修饰的变量能够保证“内存可见性”以及防止”指令重排序“

什么是可见性：当某个线程修改了某个共享变量，其他的线程是否可以看见修改后的内容；

因为访问一个变量时，CPU就会先把变量从内存中读出来，然后放到CPU寄存器中进行运算；运算完之后，再将新的数据在内存中进行刷新；

对于操作系统来讲，读内存的速度是比较慢的,(注意：这里的慢是相对于寄存器而言的，就像，读内存要比读硬盘快上千倍或上万倍，读寄存器比读内存快上千倍上万倍)，这时候就会影响执行的效率。为了提高效率，编译器就会对代码进行一个优化，把读内存的操作优化成读寄存器，从而减少对内存的读取，提高整个效率；

举个例子：

代码目的：创建两个线程，通过线程2修改线程1的循环判断条件来终止线程1的循环执行
```
public class Demo1 {
    private static int flag = 0;
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            while(flag == 0) {
                //当循环不等于0时，一直循环，直到flag被改变
            }
            System.out.println("thread1 执行结束");
        });
        Thread thread2 = new Thread(() -> {
            Scanner in = new Scanner(System.in);
            System.out.println("更改flag：");
            //通过更改flag终止线程1的执行
            flag = in.nextInt();
            System.out.println("输入成功");
        });
        thread1.start();
        thread2.start();
    }
}
```
根据结果可以看到，线程1并没有终止循环，这就是“内存可见性”所导致的线程不安全👇

在多线程的环境下(在单线程环境下没问题），如果编译器作出优化，可能就会导致bug，虽然提高了效率，但是最后结果却是错误的，

此时就需要程序员使用Volatile关键字告诉编译器，不需要进行代码优化：

直接给flag加上Volatile即可



注意， volatile只能够保证内存可见性问题，不会保证代码的原子性，但是Synchronized既可以保证内存可见性，也能保证原子性；

以上就是volatile能够保证内存可见性的讲解

💡单例模式

单例模式是一种经典的设计模式了，它的作用就是保证在有些场景下，需要一个类只能有一个对象，而不能有多个对象，比如像你以后娶媳妇，你娶媳妇肯定是只能娶一个，而不能娶两个；

但是，问题来了，一个类只需要一个对象，那在new对象的时候只new一次对象不就可以了么，为什么还要弄个这么麻烦的东西呢？

因为啊，只new一次对象确实是只有一个，但是呢，如果你在写代码的过程中忘了呢，然后又new了一次，这种概率是很大的，毕竟，人是最不靠谱的动物😅，就像是有一句话说的好：宁可相信世界上有鬼，也不要相信男人的那张嘴😂，所以的，为了防止这种失误发生，就有了单例模式，在Java中也有许多类似的机制，比如final，就会保证修饰的变量肯定是不能改变的；@override，保证你这方法肯定是一个重写方法；这些都是在语法方面进行了一些限制，但是，在语法方面，对于单例并没有特定的语法，所以，这里就通过编程技巧来达到类似的限制效果；

单例模式的两种实现方式：

💡饿汉模式

1.在类中实例化类的对象，给外界提供一个方法来使用这个对象;

2.将构造方法用private修饰，保证在类外不能再实例化这个类对象
```
public class SingleTon {
    //在类的内部实例化对象
    public static SingleTon instance = new SingleTon();
    //定义一个方法，用来获取这个对象
    //后序如果类外的代码想要使用对象时，直接调用这个方法即可
    public static SingleTon getInstance() {
        return instance;
    }
    //设置一个私有的构造方法，保证在这个类外无法实例化这个对象
    private SingleTon(){
    }
}
```
可以看到，这里的对象被static修饰，所以在类被加载的时候创建，创建的时机就比较早，并且被static修饰的对象只会被创建一次，所以这种在类加载时就创建实例的模式称为饿汉模式

💡懒汉模式

懒汉模式单线程版：

这样的写法与上面的相同点就是：同样在类外不能再第二次实例化对象，不同点是：将创建对象的时机放在getInstance方法中，这样在类加载的时候就不会创造实例，而是当第一次调用这个方法时才会去创建；
```
public class SingleTon {
    public static SingleTon instance = null;
    //定义一个方法，用来获取这个对象
    //后序如果类外的代码想要使用对象时，直接调用这个方法即可
    public static SingleTon getInstance() {
        //懒汉模式
        if(instance == null) {
            instance = new SingleTon();
        }
        return instance;
    }
    //设置一个私有的构造方法，保证在这个类外无法实例化这个对象
    private SingleTon(){
        
    }
}
```
💡懒汉模式多线程版

在线程安全方面，上面的饿汉模式是在多线程下是安全的，而懒汉模式在多线程下是不安全的；

因为，如果多个线程同时访问一个变量，那么不会出现不安全问题，如果多个线程同时修改一个变量，就有可能出现不安全问题；

饿汉模式下，只进行了访问，没有涉及到修改



懒汉模式下，不仅进行了访问，还涉及了修改，那么下面就讲解以下懒汉模式在多线程下如何会产生不安全



既然出现了不安全问题，那么如何将懒汉模式修改成安全的呢？

💡方法：进行加锁，使线程安全



但是，如果锁加在这个地方，仍然是不安全的，因为，这样还是会进行穿插执行，如果两个并发的进入的 if 语句中，那么，就会进行锁竞争，假设，thread1 获取到了锁，thread2 在阻塞等待，等到 thread1 创建一次对象，释放锁后，thread2 就又会载获取到锁，进行创建对象，所以，这个加锁操作并没有保证它是一个整体(非原子性)

所以说，并不是加了锁就安全，只有锁加对了才会安全，在加锁的时候要保证以下几方面：
1. 锁的 {} 的范围是合理的，能够把需要作为整体的每个部分都包括进去；
2. 锁的对象能够起到锁竞争的效果；
懒汉模式多线程版改进👇：

将if语句和new都放在锁里面成为一个整体，这样就避免了会穿插执行；
```
    public static SingleTon getInstance() {
        synchronized (SingleTon.class) {
            
            if(instance == null) {
                instance = new SingleTon();
            }
            
        }
        return instance;
    }
```
但是上述代码还有一个问题，每当调用getInstance时，都会尝试去进行加锁，而加锁是一个开销很大的操作，而懒汉模式之所以会出现线程不安全问题，是因为只是在第一次调用getInstance方法new对象时，可能会出现问题，但是，只要new完对象以后，就不用再进行锁竞争了，直接访问就可以了，所以再次进行优化👇：
```
    public static SingleTon getInstance() {
        //在最外面在进行一次判断
        if(instance == null) {
            synchronized (SingleTon.class) {
                if(instance == null) {
                    instance = new SingleTon();
                }
            }
        }
        return instance;
    }
```
在第一次实例化对象后，以后再调用个getInstance方法时，就不会再创建对象，而且也不会再去获取锁，因为，第一个if判断语句都不会进去，所以不会执行到加锁的语句；

上面的单例模式看着好像是完全没问题了，但是，还是有一个问题，就是可能会触发指令重排序问题，所以就需要使用volatile解决指令重排序问题：

💡volatile防止指令重排序

指令重排序：编译器会保证在你代码逻辑不变的情况下，对代码进行优化，使代码的性能得到提高，这样的操作称为指令重排序；

举个例子：

在代码中，在实例化对象这一步可能会出现指令重排序问题，下面就来讲解一下为什么👇

对于上述的指令重排序问题，解决方案就是：使用volatile关键字修饰singleTon

**线程安全的单例模式(懒汉模式)**👇
```
public class SingleTon {
    //使用volatile关键字修饰，防止指令重排序
    public static volatile SingleTon singleTon = null;
    public static SingleTon getSingleTon() {
        if(singleTon == null) {
            synchronized (SingleTon.class) {
                if(singleTon == null) {
                    singleTon = new SingleTon();
                }
            }
        }
        return singleTon;
    }
    private SingleTon() {
    };
}
```
💡💡这里再次提醒，使用单例模式要注意三个要点：
- 加锁
- 两层if判断
- 使用volatile修饰引用，防止指令重排序