Java单例模式的六种写法(▷)

文章目录

• 一, 定义
• 二,种类
• • 2.1, 饿汉式单例
  • 2.2 懒汉式单例(线程不安全)
  • 2.3, 懒汉式单例(线程安全)
  • 2.4, 双重校验锁(DCL)单例
  • 2.5, 静态内部类单例
  • 2.6, 枚举单例

一, 定义

• 单例模式: 指的是在设计一个类时,需要保证在整个程序运行期间针对该类只存在一个实例对象;

单例模式的特点:

1. 某个类只能有一个实例; ----> 1. 私有化构造方法;
2. 必须自行创建实例; ----> 2. 静态私有实例对象;
3. 必须自行向整个系统提供这个实例; ----> 3.公有静态方法;

二,种类

2.1, 饿汉式单例

public class HungrySingleton {
    //静态私有对象
    private static HungrySingleton hungrySingleton = new HungrySingleton();
    ///私有构造方法
    private HungrySingleton(){}
    ///公有外界访问方法
    public static HungrySingleton getHungrySingletonInstance(){
        System.out.println("饿汉式早在公有静态访问方法调用前就新建好了单例对象");
        return hungrySingleton;
    }
}

• 这种方式在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。 这种方式基于类加载机制避免了多线程的同步问题，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到懒加载的效果。

2.2 懒汉式单例(线程不安全)

public class LazySingleton {
    //私有化静态对象
    private static LazySingleton lazySingleton;
    //私有化构造方法
    private LazySingleton(){};
    ///公有方法
    public static LazySingleton getLazySingletonInstance(){
        if(lazySingleton == null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

• 懒汉模式申明了一个静态对象，在用户第一次调用时初始化，虽然节约了资源，但第一次加载时需要实例化，反映稍慢一些，而且在多线程不能正常工作。

2.3, 懒汉式单例(线程安全)

public class LazySingleton {
    //私有化静态对象
    private static LazySingleton lazySingleton;
    //私有化构造方法
    private LazySingleton(){};
    ///公有方法
    public static synchronized LazySingleton getLazySingletonInstance(){
        if(lazySingleton == null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

• 这种写法能够在多线程中很好的工作，但是每次调用getInstance方法时都需要进行同步，造成不必要的同步开销，而且大部分时候我们是用不到同步的，所以不建议用这种模式。

2.4, 双重校验锁(DCL)单例

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

• 这种写法在getSingleton方法中对singleton进行了两次判空，第一次是为了不必要的同步，第二次是在singleton等于null的情况下才创建实例。在这里用到了volatile关键字，不了解volatile关键字的可以查看Java多线程（三）volatile域这篇文章，在这篇文章我也提到了双重检查模式是正确使用volatile关键字的场景之一。
  在这里使用volatile会或多或少的影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。 DCL优点是资源利用率高，第一次执行getInstance时单例对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷，虽然发生的概率很小。DCL虽然在一定程度解决了资源的消耗和多余的同步，线程安全等问题，但是他还是在某些情况会出现失效的问题，也就是DCL失效，在《java并发编程实践》一书建议用静态内部类单例模式来替代DCL。

2.5, 静态内部类单例

public class Singleton { 
    private Singleton(){
    }
      public static Singleton getInstance(){  
        return SingletonHolder.sInstance;  
    }  
    private static class SingletonHolder {  
        private static final Singleton sInstance = new Singleton();  
    }  
} 

• 第一次加载Singleton类时并不会初始化sInstance，只有第一次调用getInstance方法时虚拟机加载SingletonHolder 并初始化sInstance ，这样不仅能确保线程安全也能保证Singleton类的唯一性，所以推荐使用静态内部类单例模式。

2.6, 枚举单例

public enum Singleton {  
     INSTANCE;  
     public void doSomeThing() {  
     }  
 }  

• 默认枚举实例的创建是线程安全的，并且在任何情况下都是单例，上述讲的几种单例模式实现中，有一种情况下他们会重新创建对象，那就是反序列化，将一个单例实例对象写到磁盘再读回来，从而获得了一个实例。反序列化操作提供了readResolve方法，这个方法可以让开发人员控制对象的反序列化。在上述的几个方法示例中如果要杜绝单例对象被反序列化是重新生成对象，就必须加入如下方法：

private Object readResolve() throws ObjectStreamException{
return singleton;
}

必须加入如下方法：

private Object readResolve() throws ObjectStreamException{
return singleton;
}

• 枚举单例的优点就是简单，但是大部分应用开发很少用枚举，可读性并不是很高，不建议用。