单例模式学习笔记

1 单例模式(Singleton Pattern)介绍

　1.1 单例模式介绍

　　定义：确保某一类只有一个实例，而且自行实例化并向整个系统提供这个实例。

　　实现：通过使用private的构造函数确保了在一个应用中只产生一个实例，并且是自行实例化。

　　示例代码：

　　　　例1-1

• public class Singleton01 {
      //2、创建一个对象，在类加载的时候初始
      private static final Singleton01 singleton01 = new Singleton01();
      //1、私有化构造方法，现在以new的方式创建多个对象
      private Singleton01(){
  
      }
      //3、对外提供一个静态方法，以获取实例对象
      public static Singleton01 getSingleton(){
          return singleton01;
      }
      //类中的其他方法
      public void doSomething(){
      }
  }

　　1.2 单例模式的应用

　　1.2.1 优点

• 单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁创建、销毁时，而且创建或销毁时性能无法优化，单例模式的优势就非常明显。
• 单例模式可以避免对资源的多重占用，例如一个写文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。
• 单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

　　1.2.2 缺点

• 单例模式一般没有接口，扩展困难。
• 对测试不利，如果单例模式没有完成，是不能进行测试的。

　　1.2.3 使用场景

• 要求生成唯一序列号的环境。
• 在整个项目中需要一个共享访问点或共享数据，例如一个web页面上的计数器，可以不用把每次刷新都记录到数据库中，使用单例模式保存计数器的值，并确保是线程安全的。
• 创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源。
• 需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式（当然，也可以直接声明为static的方式）。
• windows的任务管理器，工厂模式中的工厂....

2 单例模式的实现方式

　　2.1 饿汉式（线程安全，调用效率高[因为不用加锁]，但是不能延时加载），如例1-1 。

　　2.2 懒汉式 

　　当使用懒加载时（如例2-2-1），在高并发环境下，存在线程安全问题（图2-2-1），可能出现同时创建多个对象，需要对线程进行加锁（例2-2-2），此称为懒汉式，资源利用效率高，实现了懒加载，但是并发调用效率低，由于每次都要加载所有浪费系统资源。

　　例2-2-1：

• public class Singleton02 {
      //2、声明一个私有的静态变量
      private static Singleton02 singleton02 ;
      //1、私有化构造方法，现在以new的方式创建多个对象
      private Singleton02(){
      }
      //3、对外提供一个静态方法，以获取实例对象
      public static  Singleton02 getSingleton(){
          //判断singleton02是否为空，为空赋值
          if (singleton02 == null){
              singleton02 = new Singleton02();
          }
          return singleton02;
      }
  }

　　图2-2-1 

　　

　　例2-2-2：

• public class Singleton02 {
      //2、声明一个私有的静态变量
      private static Singleton02 singleton02 ;
      //1、私有化构造方法，现在以new的方式创建多个对象
      private Singleton02(){
      }
      //3、对外提供一个静态方法，以获取实例对象
      public static synchronized Singleton02 getSingleton(){
          //判断singleton02是否为空，为空赋值
          if (singleton02 == null){
              singleton02 = new Singleton02();
          }
          return singleton02;
      }
  }

　　2.3 双重检测锁(由于编译器优化原因，和jvm底层模型问题，偶尔会出现问题，不建议使用)

　　例2-3-1

• public class Singleton03 {
      //2、声明一个私有的静态成员变量
      private static Singleton03 singleton03;
      //1、私有化构造方法，现在以new的方式创建多个对象
      private Singleton03(){
      }
      //3、对外提供一个静态方法，以获取实例对象
      public static Singleton03 getSingleton(){
          //判断singleton03是否需要加锁
          if (singleton03 == null){
              synchronized (Singleton03.class){
                  if (singleton03 == null){
                      singleton03 = new Singleton03();
                  }
              }
          }
          return singleton03;
      }

　　图2-3-1

　　　

　　2.4 静态内部类（常用）

　　　　外部类没有static，所以静态内部类不会再外部类加载的时候被初始化，所以实现了懒加载

　　　　线程安全，因为实例对象是在静态内部类加载的时候创建，所以天然是单例的。

　　例2-4-1 

• public class Singleton04 {
  
      //1、私有化构造方法，现在以new的方式创建多个对象
      private Singleton04(){
      }
      //2、创建一个静态内部类
      private static class SingletonInstance{
          //静态内部类加载的时候生成单例对象
          public static Singleton04 singleton04 = new Singleton04();
      }
      //3、对外提供一个静态方法，以获取实例对象
      public static Singleton04 getSingleton(){
          //当调用该方法是，静态内部类才会被加载，对象才会new出来
          return SingletonInstance.singleton04;
      }
  }

　　2.5 枚举（线程安全，天然就单例的，能避免反射和反序列化带来的问题，但是不能懒加载）

　　例2-5-1

• public enum Singleton05 {
      SINGLETON_05;
      public void doSomething(){
      }
  }

  public class Client {
      public static void main(String[] args) {
          Singleton05 singleton05_01 = Singleton05.SINGLETON_05;
          Singleton05 singleton05_02 = Singleton05.SINGLETON_05;
          Singleton05 singleton05_03 = Singleton05.SINGLETON_05;
          System.out.println(singleton05_01);//SINGLETON_05
          System.out.println(singleton05_02);//SINGLETON_05
          System.out.println(singleton05_03);//SINGLETON_05
          singleton05_01.doSomething();
      }
  }    

3 防止反射破解单例

　　3.1反射破解单例示例：

　　例3-1-1

//破解类
public class Client {
    public static void main(String[] args) throws Exception {

        Singleton01 singleton1 = Singleton01.getSingleton();
        Singleton01 singleton2 = Singleton01.getSingleton();
        System.out.println(singleton1 == singleton2); //true

        //暴力反射破解单例
        Class<Singleton01> clazz = (Class<Singleton01>) Class.forName("com.pri.singleton_a.Singleton01");
        Constructor<Singleton01> constructor = clazz.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        Singleton01 singleton3 = constructor.newInstance(null);

        System.out.println(singleton1 == singleton3); //false
    }
}

//单例类
public class Singleton01 {
    //2、创建一个对象，在类加载的时候初始
    private static final Singleton01 singleton01 = new Singleton01();
    //1、私有化构造方法，现在以new的方式创建多个对象
    private Singleton01(){

    }
    //3、对外提供一个静态方法，以获取实例对象
    public static Singleton01 getSingleton(){
        return singleton01;
    }
    //类中的其他方法
    public void doSomething(){
    }
}

　　3.2 防止反射破解单例

　　在单例空参构造中添加判断，如

　　例3-2-1：

• public class Singleton01 {
      //2、创建一个对象，在类加载的时候初始
      private static final Singleton01 singleton01 = new Singleton01();
      //1、私有化构造方法，现在以new的方式创建多个对象
      private Singleton01(){
          if (singleton01 != null){
              throw new RuntimeException("已有实例，不能再调用此方法实例化");
          }
      }
      //3、对外提供一个静态方法，以获取实例对象
      public static Singleton01 getSingleton(){
          return singleton01;
      }
      //类中的其他方法
      public void doSomething(){
      }
  }
  
  //运行结果 ：Caused by: java.lang.RuntimeException: 已有实例，不能再调用此方法实例化

4 防止反序列化破解单例

　　4.1 反序列化破解单例

　　例4-1-1

• //破解类
  public class Client {
      public static void main(String[] args) throws Exception {
  
          Singleton01 singleton1 = Singleton01.getSingleton();
          Singleton01 singleton2 = Singleton01.getSingleton();
          System.out.println(singleton1 == singleton2); //true
  
          /*//1、将对象序列化到文件
          FileOutputStream out = new FileOutputStream("singleton.txt");
          ObjectOutputStream oos = new ObjectOutputStream(out);
          oos.writeObject(singleton1);
  
          oos.close();
          out.close();*/
  
          //2、从文件中读取对象（反序列化）
          FileInputStream input = new FileInputStream(new File("singleton.txt"));
  
          ObjectInputStream ois = new ObjectInputStream(input);
          Singleton01 singleton3 = (Singleton01) ois.readObject();
  
          System.out.println(singleton1 == singleton3); //false      
      }
  }
  
  //单例类
  public class Singleton01 implements Serializable {
      //2、创建一个对象，在类加载的时候初始
      private static final Singleton01 singleton01 = new Singleton01();
      //1、私有化构造方法，现在以new的方式创建多个对象
      private Singleton01(){
          if (singleton01 != null){
              throw new RuntimeException("已有实例，不能再调用此方法实例化");
          }
      }
      //3、对外提供一个静态方法，以获取实例对象
      public static Singleton01 getSingleton(){
          return singleton01;
      }
      //类中的其他方法
      public void doSomething(){
      }
  }

  4.2 防止反序列化破解单例

　　在单例类中添加一个readResolve（）方法，如例4-2-1.

　　例4-2-1

• public class Singleton01 implements Serializable {
      //2、创建一个对象，在类加载的时候初始
      private static final Singleton01 singleton01 = new Singleton01();
      //1、私有化构造方法，现在以new的方式创建多个对象
      private Singleton01(){
          if (singleton01 != null){
              throw new RuntimeException("已有实例，不能再调用此方法实例化");
          }
      }
      //3、对外提供一个静态方法，以获取实例对象
      public static Singleton01 getSingleton(){
          return singleton01;
      }
      //类中的其他方法
      public void doSomething(){
      }
  
      //反序列化时，直接return singleton01,不生成对象
      private Object readResolve() throws ObjectStreamException{
          return singleton01;
      }
  }