1.1. 单例模式

在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。

1.1.1. 单例模式优点和缺点

优点：

• 单例模式可以保证内存里只有一个实例，减少了内存的开销。
• 可以避免对资源的多重占用。
• 单例模式设置全局访问点，可以优化和共享资源的访问。 缺点：
• 单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。
• 在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。
• 单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

  1.1.2. 单例模式的应用场景

• 需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少 GC。
• 某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。
• 频繁访问数据库或文件的对象。
• 当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。

  1.1.3. 实现单例的模式的几种方式

• 饿汉模式
• 懒汉模式
• DCL双端检锁机制
• 枚举模式
• 静态内部类模式

  1.1.4. 实例代码

  ```java /**
  • @author lviter
  • 单例模式的四种实现：
  • 1. 饿汉
  • 1. 懒汉
  • 1. DCL双端检锁机制
  • 1. 静态内部类
  • 1. 枚举模式 */ public class Singleton { public static void main(String[] args) { SingletonEnum s1 = SingletonEnum.INSTANCE.getInstance(); SingletonEnum s2 = SingletonEnum.INSTANCE.getInstance(); System.out.println(s1 == s2); } }

/**

• 懒汉式--线程不安全 */ class SingletonLazy { private static SingletonLazy singletonLazy = null;

  private SingletonLazy() {

   System.out.println("懒汉式---线程不安全的构造方法");
  

  }

  public static SingletonLazy getSingletonLazy() {

   if (singletonLazy == null) {
       return new SingletonLazy();
   }
   return singletonLazy;
  

  } }

/**

• 饿汉式
• 没有加锁，执行效率会提高。缺点是类加载时就初始化，浪费内存

• 基于classloder机制避免了多线程的同步问题 */ class SingletonHungry { private static final SingletonHungry singletonHungry = new SingletonHungry();

  private SingletonHungry() {

   System.out.println("饿汉式");
  

  }

  public static SingletonHungry getSingletonHungry() {

   return singletonHungry;
  

  } }

/**

• DCL:double check lock,双端检锁机制--在同步锁前后都增加检查操作

• 多线程安全，采用双锁机制，安全且在多线程下保持高性能。 */ class SingletonDcl {

  private volatile static SingletonDcl singletonDcl;

  private SingletonDcl() {

   System.out.println("DCL双端检锁--线程安全，支持高性能");
  

  }

  /**

  • 同步锁前后都增加检查 *
  • @return */ public static SingletonDcl getSingletonDcl() { if (singletonDcl == null) {

     synchronized (SingletonDcl.class) {
         if (singletonDcl == null) {
             singletonDcl = new SingletonDcl();
         }
     }
    

    } return singletonDcl; } }

/**

• 静态内部类的构造方法只会在调用他的时候触发，所以是线程安全的 */ class SingletonStaticInternal {

  private SingletonStaticInternal() {

   System.out.println("这里是静态内部类的方式");
  

  }

  private static class holder {

   private static final SingletonStaticInternal instance = new SingletonStaticInternal();
  

  }

  public static SingletonStaticInternal getInstance() {

   return holder.instance;
  

  } }

/**

• 枚举单例(单例模式的最佳实现方法)

• 既可以避免多线程同步问题；还可以防止通过反射和反序列化来重新创建新的对象 / enum SingletonEnum { /*

  • 单例 */ INSTANCE;

    public SingletonEnum getInstance() { return INSTANCE; }

    public void m() { System.out.println("枚举类"); } } ```