实现单例设计模式的 另外4种方式

1、懒汉式：线程不安全，同步代码块（这种写法有问题）

1.1 代码演示

  1. class Singleton5{
  2.     //成员变量
  3.     private static Singleton5 instance;
  5.     //1.构造器私有化
  6.     private Singleton5(){}
  8.     //2.提供一个静态的getInstance()方法
  9.     //当使用该方法时，才去创建实例，既懒汉式
  10.     //当判断instance为null，在创建对象实例的时候才去进行同步
  11.     public static Singleton5 getInstance(){
  12.         if (instance == null){
  13.             synchronized (Singleton5.class){
  14.                 instance = new Singleton5();    
  15.             }
  16.         }
  17.         return instance;
  18.     }
  19. }

1.2 优缺点：

  1. 连线程安全的问题都解决不了

**

  1. 这种方式的本意是想对第四种实现方式的改进，因为前面同步方法效率太低，改为同步产生实例化的代码块


  1. 但是这种同步并不能起到线程同步的作用


  1. 结论：在开发中不要使用这种方式

2、双重检查

解决了线程安全问题和效率问题 懒加载，推荐使用

volatile关键字的作用：保证了变量的可见性（visibility），被volatile关键字修饰的变量，如果值发生了变更，其他线程立马可见，避免出现脏读的现象

2.1 代码实现：

  1. class Singleton6{
  2.     //成员变量
  3.     private static volatile Singleton6 instance;
  5.     //1.构造器私有化
  6.     private Singleton6(){}
  8.     //2.提供一个静态的getInstance()方法
  9.     //当使用该方法时，才去创建实例，既懒汉式
  10.     //加入双重检查代码，解决了线程安全问题，统姐解决懒加载问题
  11.     public static Singleton6 getInstance(){
  12.         if (instance == null){
  13.             synchronized (Singleton6.class){
  14.                 if (instance == null){
  15.                     instance = new Singleton6();    
  16.                 }
  17.             }
  18.         }
  19.         return instance;
  20.     }
  21. }

2.2 优缺点：

  1. 双重检查Double-Check 概念是多线程开发中使用最常用的，如代码中所示他进行了两次if判断，这样就保证了线程安全


  1. 这样实例化代码只需执行一次，后面的在进入时 第一个if就直接return了 实例对象


  1. 线程安全；延迟加载；效率较高

**

  1. 结论：在实际开发中，推荐使用这种单例设计模式

3、静态内部类

3.1 静态内部类：

  1. 当主类加载时，静态内部类不会被加载（保证了懒加载）

  2. 当我们去调用Singleton里面的方法用到了里面的静态内部类的变量，会进行装载静态内部类

    3.2 代码演示

    1. class Singleton7{
    2.  //1.构造器私有化
    3.  private Singleton7(){}
    5.  //2.提供一个静态内部类
    6.  private static class Singleton7Instance{
    7.      private static final Singleton7 INSTANCE  = new Singleton7();
    8.  }
    9.  //3.提供一个对外的静态方法，用来获取实例
    10.  public static Singleton7 getInstance(){
    11.      return Singleton7Instance.INSTANCE;
    12.  }
    13. }

    3.3 优缺点：

  3. 这种方式采用了类装载的机制保证初始化实例时只有一个线程。


  1. 静态内部类方式在Singleton类被装载时并不会立刻实例化，而是在调用getInstance()方法时才会装载静态内部类，因为调用了静态内部类的属性


  1. 类的静态属性只会在第一次加载类的时候初始化 final关键字，所以在这里，JVM帮我们保证了现成的安全性，在类进行初始化时，别的线程是无法进入的


  1. 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高


  1. 结论：在实际开发中，推荐使用

4、枚举

4.1 代码实现：

  1. enum Singleton8{
  2.    INSTANCE;
  3.    public void method(){
  4.        System.out.println("ok~~");
  5.     }
  6. }

4.2 优缺点：

  1. 借助了JDK1.5的枚举来实现单例模式，不仅能避免多线程同步问题，而且还能防止范徐丽话重新创建新的对象


  1. 结论：推荐使用