设计模式之单例模式

有时候需要控制一个类只创建一个对象，比如说创建这个对象比较消耗性能、或者这个类比较占用内存，那么就可以通过单例模式来设计这个类。

思考

单例模式的实质是控制实例数量，当需要控制一个类的实例只能有一个时，使用单例模式。

使用场景

• java中缓存的实现：正是一种懒汉式的方式，查询的时候初始化缓存一次，之后访问每次访问初始化的缓存对象
• 数据库连接池：
• 线程池：

代码实现

饿汉式

• 结构

  1. 私有化无参构造函数
  2. 创建一个static修饰的对象
  3. 提供一个公共的static修饰的方法返回实例对象

• 优点

  1. 线程安全
  2. 空间换时间

//饿汉式
public class Singleton {
    //2定义一个静态变量来存储创建好的类实例直接在这里创建类实例，由虚拟机来保证只会创建一次
    private static final Singleton instance = new Singleton();
    //1：私有化构造方法，好在内部控制创建实例的数目
    private Singleton(){        
        //初始化加载后创建对象，判断不为空，再次创建，抛出异常，防止反射创建
        if (instance != null){
            throw new IllegalStateException("Already instantiated");
        }
    }
    //3：这个方法需要定义成类方法，也就是要加static
    public static Singleton getInstance(){
        return instance;
    }
    public static void main(String[] args) {
        for(int i=0;i<3;i++){
            System.out.println(Singleton.getInstance());
        }
    }
}

懒汉式

• 结构

  1. 私有化构造方法
  2. 提供一个公共的static修饰的方法获取实例
  3. 双重NULL判断，加锁创建实例对象返回
  4. 实例对象使用volatile修饰

• 优点

  1. 节省空间
  2. 加锁同步后性能低于饿汉式

public class Singleton {
    //对保存实例的变量添加volatile的修饰,防止指令重排
    private volatile static Singleton instance = null;
    private Singleton(){
    }
    public static  Singleton getInstance(){
        //先检查实例是否存在，如果不存在才进入下面的同步块
        if(instance == null){
            //同步块，线程安全的创建实例
            synchronized(Singleton.class){
                //再次检查实例是否存在，如果不存在才真的创建实例
                if(instance == null){
          //使用volatile修饰，避免重排序，锁内的代码也会发生重排序
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

这里使用volatile的原因为了防止指令重排序,避免获取到一个未初始化完成的对象

instance=new Singleton()；可以分为以下3步完成（伪代码）
memory=allocate(): // 1.分配对象内存空间
instance(memory): // 2.初始化对象
instance=memory; //3. 设置instance指向刚分配的内存地址，此时instance != null

步骤2依赖步骤1，步骤3不依赖步骤2，所以有可能发生指令重排序，先执行1，再执行3，再执行2，假如线程A执行完步骤3还没执行步骤2的时候，线程B进入判断 instance!=null，直接会获取一个未初始化的对象去使用

类级内部类实现单例

public class Singleton {
     //类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例没有绑定关系，而且只有被调用到才会    //装载，从而实现了延迟加载
    private static class SingletonHolder{
        //静态初始化器，由JVM来保证线程安全，这里会发生重排序，但是是发生在SingletonHolder实例完成之前，不影响所以不用加volatile
        private static final Singleton instance = new Singleton();
    }
    // 私有化构造方法
    private Singleton(){
    }
    public static  Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

该模式依赖classloader类加载器线程安全来实现。ClassLoader的loadClass方法在加载类的时候使用了synchronized关键字

枚举实现单例

java中的枚举其实是一种多例的实现，在枚举中只定义一个实例，那么就是最简单的一种单例模式

public enum Singleton { 
    
    uniqueInstance("test");
    private Singleton(String name){ 
    }
}

使用CAS 无锁

public class Singleton {
    private Singleton(){}
    //使用AtomicReference保证内存可见性
    private static AtomicReference<Singleton> instance = new AtomicReference<>();
    public static Singleton getInstance(){
        //死循环中compareAndSet
        for(;;){
            if(instance.get() == null){
                Singleton singleton = new Singleton();
                //compareAndSet成功 返回，否则继续循环
                if(instance.compareAndSet(null, singleton)){
                    return instance.get();
                }
            }else{//已经创建成功则返回
                return instance.get();
            }
        }
    }
}

CAS既保证了线程安全，又避免了锁等待导致的线程切换和阻塞，性能相对好一些，但是如果一直创建对象不成功，则会导致死循环，CPU开销大。同时还有一个问题，当大量线程同时到达的时候，都会执行 Singleton singleton = new Singleton();导致大量Singleton对象创建。不建议使用这种方式

针对以上问题优化后CAS实现单例

public class Singleton {
    private Singleton(){}
    //使用 volatile 防止重排序
    private static volatile Singleton instance = null;
    private static AtomicBoolean flag = new AtomicBoolean(false);
    public static Singleton getInstance(){
        //死循环中compareAndSet
        for(;;){
            if(instance == null){
                //compareAndSet成功 返回，否则继续循环
                if(flag.compareAndSet(false, true)){
                    try {
                        instance = new Singleton();
                    }catch (Exception e){
                        //防止创建对象异常
                        if (instance == null){
                            flag.set(false);
                        }
                    }
                    return instance;
                }
            }else{//已经创建成功则返回
                return instance;
            }
        }
    }
}