关于单例模式中volatile的使用

单例模式

在设计模式当中，有一种设计方式叫做单例模式。

所谓的单例模式，就是保证一个类中只有一个实例

该类负责创建自己的对象，同时确保只有单个对象被创建。

他有几点注意事项：

单例类只能有一个实例。

单例类必须自己创建自己的唯一实例。

单例类必须给所有其他对象提供这一实例。别人可以查询到创建的实例

接下来就是根据定义来创建一个单例模式

步骤1 创建一个唯一的对象
public class SingleObject {
   //类加载的时候，创建唯一一个对象instance
   private static SingleObject instance = new SingleObject();
   //让构造函数为 private，这样该类就不会被实例化
   private SingleObject(){}
   //获取唯一可用的对象
   public static SingleObject getInstance(){
      return instance;
   }
   public void showMessage(){
      System.out.println("这个一条是信息!");
   }
}

步骤2 获取唯一的对象 
class Test{
public static void main(String[] agrs){
        /不合法的构造函数
      //编译时错误：构造函数 SingleObject() 是不可见的
      //他不能通过构造方法来创建对象 
      //SingleObject object = new SingleObject();
      //获取唯一可用的对象
      SingleObject object = SingleObject.getInstance();
      //显示消息
      object.showMessage();
    }
}

结果
 这个一条是信息!

那么思路到这里应该都理解了，接下来就是单例的模式的实现模式：

懒汉式（懒啊，第一次要用到对象的时候我再创建），线程不安全

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

不支持多线程，严格来说不算单例模式

懒汉式（第一次要用到对象的时候我再创建），线程安全

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

必须加锁 synchronized 才能保证单例，但加锁会影响效率。

饿汉式（一开始就创建了，生怕没吃的）

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

它在类刚被加载的时候，就各种创建对象，如果我暂时还不需要的话，这样其实是会造成资源的浪费的

静态内部类

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    //使用静态内部类
    private static class Single{
         private static Singleton instance = new Singleton();  
    }
    
    public static Singleton getInstance() {  
    return Single.instance;  
    }  
}
使用类加载器保证线程安全。
外部类加载时并不需要立即加载内部类
在需要实例化时，调用getInstance方法，才会加载Single类中，实例化Singleton

枚举

public enum SingleTon{
     INSTANCE;
        public void method(){
     }
}

最佳的方法，但是今天的重点不是这个，所以并没有深入学习，用的不是很多

双重校验锁

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

双重检查模式

在之前学习volatile的时候，发现了，对可变的共享数据进行放回，如果没有保证同步，会出现不可预期的结果。

以及单例模式的时候，我们发现了一个模式叫做双重校验锁，他使用到了volatile。假如没有使用volatile会出现什么情况呢。

public class Singleton {  
    
  private  static Singleton singleton;  
    
   private Singleton (){}  
  
  public static Singleton getSingleton() {  
            if (singleton == null) {  
                synchronized (Singleton.class) {  
                    if (singleton == null) {  
                       // singleton = new Singleton();  
                    }  
                }  
            }  
            return singleton;  
            }  
}

看起来好像没有问题，类加载的时候延迟创建唯一实例。

java相关的对象创建的流程，他有部分一下流程：

内存分配

初始化

返回对象在堆上的引用

接下来假设一个案例：

多线程A与多线程B，同时调用getSingleton（）获取singleton的时候。

线程A--》我并没按照顺序创建了对象，给内存返回了对象在堆上的引用，但是我还没有初始化

线程B--》我检查到对应地址啦，不是空，那我可以用了。

---》实际上sinleton还没完全创建好，这一用就出现了问题

volatile

在学习volatile的过程中我们发现了volatile可以保证有序性，可见性

那么上述出现的问题就是对象的创建没有保证顺序，volatile关键字他可以禁止指令重排序来保证一定的有序性，所这个时候就不会出现问题了