设计模式-单例模式

单例模式

单例模式属于创建型模式。单例模式就是在程序运行中只实例化一次，创建一个全局唯一的对象，有点像Java的静态变量，但是单例模式要优于静态变量，静态变量在程序启动的时候JVM就会进行加载，如果不使用则会造成资源浪费。单例模式能够实现懒加载，能够在使用实例的时候才去创建实例对象。

单例的好处

• 只有一个对象，内存开支少，性能好
• 避免对资源的多重占用
• 在系统设置全局访问点，优化和共享资源访问

单例模式的实现

饿汉式单例

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }
}

public class Singleton {
    private static Singleton instance;

    static {
        instance = new Singleton();
    }

    private Singleton() {
    }

    public synchronized static Singleton getInstance() {
        return instance;
    }
}

优点

• 写法简单，在类加载的的时候就完成了初始化。避免了线程安全问题

缺点

• 不能实现懒加载，造成内存浪费。如果一个类比较大，我们在初始化的时候就加载这个类，但是长时间不使用，就造成了内存空间的浪费

懒汉式单例

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

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

懒汉模式是一种懒加载的模式，在程序初始化时不会创建实例，只有在使用实例的时候参会创建实例，所以懒汉模式解决了饿汉模式带来的内存浪费问题，同时也引入了多线程不安全的问题。因为它不能保证时单例模式，有可能出现多实例的情况。

假如有两个线程都进入 if (instance == null) 这个位置，以为没任何资源保护措施，所以两个线程可以同时判断instance为空，都去执行 instance = new Singleton();实例化代码，所以会出现多份实例的情况。

通过分析出问题，如果对创建实例的地方进行资源保护，是不是可以解决线程安全问题，给 getInstance() 方法加上关键字 synchronized 关键字，使得调用 getInstance() 方法时只有一个线程持有，修改代码如下：

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

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

经过修改后，解决了多线程安全的问题。但是加锁后是的线程串行，只有持有锁的线程才能去执行代码，这会使得性能大大下降。

优点

• 实现了懒加载，节约了内存空间

缺点

• 不加锁的情况先存在线程安全问题
• 在加锁的情况下，造成多线程串行化，存在性能问题

双重检查模式

双重检查模式是上述懒加载加锁情况的一个优化，对于getInstance()方法来说，绝大多数的操作都是读操作，读操作是线程安全的，所以我们没必要让每个线程必须持有锁才能调用该方法，我们需要调整加锁问题，因此产生了双重检查模式。

public class Singleton {
    private volatile static Singleton singleton;

    private Singleton() {
    }
    
    public static Singleton getInstance() {
        //性能优化，只有在对象为空的时候加上同步锁
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

• 优点

  1. 延迟初始化。和懒汉模式一致，只有在初次调用静态方法getInstance()，才会初始化实例
  2. 性能优化。同步会造成性能下降，在同步前通过实例对象是否初始化，减少不必要的同步开销
  3. 线程安全。同步创建实例对象，注意静态变量singleton使用 volatile 修饰

  虽然使用synchronized同步，但是会存在重排序的问题。

  问题根源

  问题出现在创建对象语句**singleton = new Singleton();**上，在java中创建一个对象并非一个原子操作，可以分为三步：

  //1.分配对象的内存空间
  memory = allocate();
  //2.初始化对象
  ctorInstance(memory);
  //3.设置instance指向刚分配的内存地址
  instance = memor;
  

  上面的伪代码中步骤2，3之间，可能会存在重排序，即编译器或者处理器为提高性能改变代码的执行顺序。

  重排序后的伪代码是这样的：

  //1.分配对象的内存空间
  memory = allocate();
  //3.设置instance指向刚分配的内存地址
  instance = memor;
  //2.初始化对象
  ctorInstance(memory);
  

  在单线程下，重排序不会对最终的结果产生影响，但是在并发情况下，可能会导致某些线程访问到未初始化的变量

  场景模拟：

  时间	线程1	线程2
  t1	Thread1:分配对象内存空间
  t2	Thread1:设置instance指向内存空间
  t3		Thread2：判断instance是否为空
  t4		Thread2:由于instance不为空，线程2将访问instance引用对象
  t5	Thread1:初始化对象
  t6	Thread1:访问instance引用对象

  按照这样的顺序执行，线程2将获得一个未初始化的对象。并且线程2自始自终无需获取锁。

  所以为了解决该问题则需要用volatile来修饰确保原子性，对于volatile的印象是它保证了“可见性”，它的“可见性”是通过它的内存语义实现的：

  • 写volatile修饰的变量时，JMM会把本地内存中值刷新到主内存
  • 读volatile修饰的变量时，JMM会设置本地内存无效

静态内部类模式

public class Singleton {

    //静态内部类单例
    private Singleton() {
    }

    public static Singleton getInstance() {
        return SingletonHoler.instance;
    }

    private static class SingletonHoler {
        private static final Singleton instance = new Singleton();
    }
}
   

• 优点

  1. 延迟初始化。外部类加载是并不需要立即加载内部类，内部类不被加载则不去初始化instance，故而不占内存
  2. 线程安全。JVM在执行类的初始化阶段，会获得一个可以同步对线程同一个类的初始化锁

  如何确保线程安全

  在getInstance()方法，调用的是SingletonHolder.instance，取的是SingletonHolder里的instance对象，跟双重检查单例方法不同的是，getInstance()方法并没有多次new对象，故不管多少线程调用getInstance()方法，取的都是同一个instance对象，而不用重新创建。当getInstance()方法被调用时，SingletonHoler在Singleton常量池中，把符号引用替换为直接引用，这是静态对象instance也真正被创建，然后再被getInstance()方法返回出去。那么instance在创建的过程中是如何保证线程安全的呢？在**《深入理解Java虚拟机》**中有一句话：

  虚拟机会保证一个类的**()方法在多线程环境中被正确的加锁，同步。如果对线程同时取初始化一个类，那么只会有一个线程去执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行()方法完毕**。如果一个类的()方法中有很耗时的操作，就会造成对个进程阻塞（需要注意的是，其他线程虽然会被阻塞，但如果执行()方法后，其他线程唤醒之后不会再次进入()方法。同一个加载器下，一个类型只会初始化一次。），实际开发中，这种阻塞往往是很隐蔽的。

• 缺点

由于是静态内部类的形式创建单例的，故无法传递参数进去。

枚举单例模式

public enum Singleton {
    instance;

    public void doSomething() {
    }
}

枚举在Java与普通类一样，都能拥有字段与方法，而且枚举实例创建时线程安全的，在任何情况下，他都是一个单例。可以直接以Singleton.instance的方式调用。而且还能防止反序列化重新创建新对象，防止反射