一、创建型模式

创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。

这样可以降低系统的耦合度，使用者不需要关注对象的创建细节。

创建型模式分为：

• 工厂方法模式

• 抽象工厂模式

• 建造者模式

1.1 单例设计模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

1.1.1 单例模式的结构

单例模式的主要有以下角色：

• 单例类。只能创建一个实例的类

• 访问类（测试类）。使用单例类

1.1.2 单例模式的实现

单例设计模式分类两种：

饿汉式：类加载就会导致该单实例对象被创建

懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

1. 饿汉式-方式1（静态变量方式）

   /**
    * 饿汉式
    *      静态变量创建类的对象
    */
   public class Singleton {
       //私有构造方法
       private Singleton() {}
   ​
       //在成员位置创建该类的对象
       private static Singleton instance = new Singleton();
   ​
       //对外提供静态方法获取该对象
       public static Singleton getInstance() {
           return instance;
       }
   }

   该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。

   用下面的代码来验证一下

   public class Client {
       public static void main(String[] args) {
           //创建Singleton类的对象
           Singleton instance = Singleton.getInstance();
   ​
           Singleton instance1 = Singleton.getInstance();
   ​
           //判断获取到的两个是否是同一个对象
           System.out.println(instance == instance1);
       }
   }

   可以得出单例模式得到的对象是一模一样的。

   

2. 饿汉式-方式2（静态代码块方式）

   /**
    * 饿汉式
    *      在静态代码块中创建该类对象
    */
   public class Singleton {
   ​
       //私有构造方法
       private Singleton() {}
   ​
       //在成员位置创建该类的对象
       private static Singleton instance;
   ​
       static {
           instance = new Singleton();
       }
   ​
       //对外提供静态方法获取该对象
       public static Singleton getInstance() {
           return instance;
       }
   }

   该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的方式1基本上一样，当然该方式也存在内存浪费问题。

   验证方式同上可得出相同结论。

3. 懒汉式-方式1（线程不安全）

   /**
    * 懒汉式
    *  线程不安全
    */
   public class Singleton {
       //私有构造方法
       private Singleton() {}
   ​
       //在成员位置创建该类的对象
       private static Singleton instance;
   ​
       //对外提供静态方法获取该对象
       public static Singleton getInstance() {
           //判断instance是否为null，如果为null，说明还没有创建Singleton类的对象
           //如果没有，创建一个并返回，如果有，直接返回
           if(instance == null) {
               //线程1等待，线程2获取到cpu的执行权，也会进入到该判断里面
               instance = new Singleton();
           }
           return instance;
       }
   }

   从上面代码我们可以看出该方式在成员位置声明Singleton类型的静态变量，并没有进行对象的赋值操作，那么什么时候赋值的呢？当调用getInstance()方法获取Singleton类的对象的时候才创建Singleton类的对象，这样就实现了懒加载的效果。但是，如果是多线程环境，会出现线程安全问题。

4. 懒汉式-方式2（线程安全）

   /**
    * 懒汉式
    *  线程安全
    */
   public class Singleton {
       //私有构造方法
       private Singleton() {}
   ​
       //在成员位置创建该类的对象
       private static Singleton instance;
   ​
       //对外提供静态方法获取该对象
       public static synchronized Singleton getInstance() {
   ​
           if(instance == null) {
               instance = new Singleton();
           }
           return instance;
       }
   }

   该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。

5. 懒汉式-方式3（双重检查锁）

   再来讨论一下懒汉模式中加锁的问题，对于 getInstance() 方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机。由此也产生了一种新的实现模式：双重检查锁模式

   /**
    * 双重检查方式
    */
   public class Singleton { 
   ​
       //私有构造方法
       private Singleton() {}
   ​
       private static Singleton instance;
   ​
      //对外提供静态方法获取该对象
       public static Singleton getInstance() {
           //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
           if(instance == null) {
               synchronized (Singleton.class) {
                   //抢到锁之后再次判断是否为null
                   if(instance == null) {
                       instance = new Singleton();
                   }
               }
           }
           return instance;
       }
   }

   双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

   要解决双重检查锁模式带来空指针异常的问题，只需要使用 volatile 关键字, volatile 关键字可以保证可见性和有序性。

   /**
    * 双重检查方式
    */
   public class Singleton {
   ​
       //私有构造方法
       private Singleton() {}
   ​
       private static volatile Singleton instance;
   ​
      //对外提供静态方法获取该对象
       public static Singleton getInstance() {
           //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实际
           if(instance == null) {
               synchronized (Singleton.class) {
                   //抢到锁之后再次判断是否为空
                   if(instance == null) {
                       instance = new Singleton();
                   }
               }
           }
           return instance;
       }
   }

   添加 volatile 关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题。

6. 懒汉式-方式4（静态内部类方式）

   静态内部类单例模式中实例由内部类创建，由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。静态属性由于被 static 修饰，保证只被实例化一次，并且严格保证实例化顺序。

   /**
    * 静态内部类方式
    */
   public class Singleton {
   ​
       //私有构造方法
       private Singleton() {}
   ​
       //定义一个静态内部类
       private static class SingletonHolder {
           //在内部类中声明并初始化外部类的对
           private static final Singleton INSTANCE = new Singleton();
       }
   ​
       //对外提供静态方法获取该对象
       public static Singleton getInstance() {
           return SingletonHolder.INSTANCE;
       }
   }

   验证是否正确的方式同上。

   第一次加载Singleton类时不会去初始化INSTANCE，只有第一次调用getInstance，虚拟机加载SingletonHolder

   并初始化INSTANCE，这样不仅能确保线程安全，也能保证 Singleton 类的唯一性。

   静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。

7. 枚举类实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。

   /**
    * 枚举方式
    */
   public enum Singleton {
       INSTANCE;
   }

   枚举方式属于饿汉式方式。

   未完待续。。。

如果您觉得阅读本文对您有帮助，请点一下“推荐”按钮，您的“推荐”将是我最大的写作动力！欢迎各位转载，但是未经作者本人同意，转载文章之后必须在文章页面明显位置给出作者和原文连接，否则保留追究法律责任的权利。