Simpleton-单例模式

单例模式

定义：采取一定的方法保证在整个软件系统中，某一个类只有一个对象实例，并且该类值提供一个取得该对象的实例方法。

单例模式类图

单例模式的实现方式

1. 饿汉式

• 静态常量

  步骤：

  1. 构造器私有化
  2. 类的内部创建对象
  3. 向外暴露一个静态的公共方法
  4. 代码实现

  优点：写法比较简单，在类装载的时候就完成了实例化。避免了线程同步问题。

  缺点：在类装载的时候就完成了实例化，没有达到Lazy Loading的效果。如果从始至终没有使用过这个类，就会造成内存浪费。

  package Singleton.hungryMan;
  
  // 饿汉式 静态变量
  class Singleton01 {
      // 1. 构造器私有化
      private Singleton01 () {}
      // 2. 类的内部创建对象
      private static final Singleton01 singleton = new Singleton01();
      // 3. 向外暴露一个静态的公共方法
      public static Singleton01 getInstance() {
          return singleton;
      }
  }
  

• 静态代码块

  优缺点与静态常量一样，仅仅是将创建对象放在了静态代码块中

  package Singleton.hungryMan;
  
  // 饿汉式静态代码块
  class Singleton02 {
      // 1. 构造器私有化
      private Singleton02 () {}
  
      // 2. 类的内部创建对象
      private static Singleton02 singleton;
      static { // 在静态代码块中，创建单例对象
          singleton = new Singleton02();
      }
  
      // 3. 向外暴露一个静态的公共方法
      public static Singleton02 getInstance() {
          return singleton;
      }
  }
  
  

2. 懒汉式

• 线程不安全

  package Singleton.LazyMan;
  
  // 懒汉式，线程不安全
  class Singleton1 {
      private static Singleton1 instance;
  
      private Singleton1 () {}
      
      public static Singleton1 getInstance () {
          if (instance == null) {
              instance = new Singleton1();
          }
          return instance;
      }
  }
  

  说明

  1. 起到了Lazy Loading的效果，但是只能在单线程下使用

  2. 如果多线程条件下，一个线程进入 if (instance == null)语句块，还未来的及往下执行，另一个线程也通过了判断条件，就会产生多个实例。

• 线程安全

  ​ 同步方法

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

  ​ 说明

  1. 解决了线程不安全
  2. 效率太低，每个线程想要获得类的实例的时候，执行getInstance()方法都要进行同步，实际上只需要在第一次创建的时候防止同时创建调用就可以了，其他时候也需要同步，降低了效率。

  ​ 同步代码块

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

  ​ 这种同步并不能起到线程同步的作用，只要有多个线程通过if判断但是停在锁前，就会出现线程不安全的问题，就会产生多个实例。

3. 双重检查

class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {}
    
  	// 提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决LazyLoading问题 
    public static synchronized Singleton getInstance () {
       if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
}

​ 关于volatile关键字可以查看 彻底理解Volatitle

说明

1. Double-Check进行了两次对对象是否为空的判断，这样保证了线程的安全
2. 并且实例化代码值用执行一次，后面再次访问在最外层判断就直接返回了，避免了反复进行方法同步
3. 线程安全，延迟加载，效率高

4. 静态内部类

特点：

1. 外部类被装载的时候静态内部类不会一同被装载
2. 调用静态内部类中创建的对象时，静态内部类才会被装载，并且线程安全

class Singleton {
    private Singleton () {}

    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance () {
        return SingletonInstance.INSTANCE;
    }
}

​ 说明

1. 这种方式采用了类装载的机制来保证初始化实例时只有一个线程
2. 类的静态属性只会在第一次家在类的时候初始化，所以保证了线程安全，在类的初始化时，别的线程无法进入
3. 避免了线程不安全，利用静态内部类特点实现了延时加载，效率高

5. 枚举

enum Singleton {
    INSTANCE;
}

说明

• 不仅能够避免多线程问题，还可以防止反序列化重新创建对象

单例模式在JDK中的应用

jdk中的RunTime就是单例模式

@我的gitpage： https://zxk0212.github.io/