你知道23种基础设计模式有哪些吗？单例模式中饿汉式以及懒汉式又有什么区别？

设计模式：设计模式是为了在特定场景解决特定的问题而提出的设计模式，是针对不同场景下，如何达到特定需求的一种解决方案，许多的设计模式在众多开发人员在漫长的开发过程当中针对一些比较常见的通用性问题的而提出的比较好的解决方案。

面向对象的23种基础设计模式：

创建型模式（关注对象创建过程的模式）	结构形模式（关注类和对象组合的模式）	行为型模式（关注对象之间通讯过程）
工厂方法模式	桥接模式	备忘录模式
建造者模式	代理模式	解释器模式
抽象工厂模式	享元模式	命令模式
原型模式	装饰器模式	中介者模式
单例模式	组合模式	观察者模式
-	-	策略模式
-	-	状态模式
-	-	模板方法模式
-	-	访问者模式
-	-	迭代子模式
-	-	责任链模式

本篇主要探讨“单例模式”的使用

单例模式的定义：一个类有且只有一个唯一的实例，并且可以自行实例化向整个系统提供。
根据定义要如何进行设计呢？

设计要点	实现方法
该类只有有一个实例	构造方法私有化
该类有自行创建实例的能力	成员属性含有一个该类的静态私有对象
能够为整个系统提供这个唯一的实例对象	提供一个共有的静态方法用于创建，获取静态私有对象

总结：限制类实例化对象的渠道，把创建对象的控制权掌握在自己手中。将自行创建的对象保存到静态私有的成员属性当中。提供一个共有的静态方法以便外界来获取该类的实例对象。

单例模式代码实现方案分为两种形式:

1. 饿汉式（线程安全的）
   – 声明变量的过程中实例化对象。

2. 懒汉式（线程不安全的）
   – 第一次获取该对象的过程中才实例化对象。

1，饿汉式

package singleton.demo;
/*饿汉式-单例模式*/
public class SingletonOne {
    /*定义一个私有构造方法*/
    private SingletonOne(){}
    /*定义一个私有的静态成员属性而且立即调用构造方法创建该类实例对象将其保存在该静态成员属性当中*/
    private static SingletonOne instance = new SingletonOne();
    /*提供一个获取该类对象的共有静态方法*/
    public static SingletonOne getInstance(){
        return instance;
    }
}

2，懒汉式

package singleton.demo;
/*懒汉式-单例模式*/
public class SingletonTwo {
    /*定义一个私有构造方法*/
    private SingletonTwo(){}
    /*定义一个私有的静态成员属性将该对象的引用指向null*/
    private static SingletonTwo instance = null;
    /*提供一个获取该类对象的共有静态方法，第一次调用该方法的时候会创建该类的实例对象并且将其保存在静态成员属性中*/
    public static SingletonTwo getInstance(){
        if (instance == null){
            instance = new SingletonTwo();
        }
        return instance;
    }
}

测试代码

package singleton.test;

import singleton.demo.SingletonOne;
import singleton.demo.SingletonTwo;

public class SingletonTest {
    public static void main(String[] args) {
        /*饿汉式-单例模式-测试*/
        System.out.println("饿汉式-单例模式-测试");
        SingletonOne singletonOne_one = SingletonOne.getInstance();
        SingletonOne singletonOne_two = SingletonOne.getInstance();
        System.out.println("singletonOne_one:"+singletonOne_one);
        System.out.println("singletonOne_one:"+singletonOne_two);
        System.out.println("是否为同一个对象:"+singletonOne_one.equals(singletonOne_two));
        System.out.println("*************************");
        /*懒汉式-单例模式-测试*/
        System.out.println("懒汉式-单例模式-测试");
        SingletonTwo singletonTwo_one = SingletonTwo.getInstance();
        SingletonTwo singletonTwo_two = SingletonTwo.getInstance();
        System.out.println("singletonTwo_one:"+singletonTwo_one);
        System.out.println("singletonTwo_two:"+singletonTwo_two);
        System.out.println("是否为同一个对象:"+singletonTwo_one.equals(singletonTwo_two));
    }
}

输出结果：

总结：
【饿汉式-单例模式】在类加载的过程中就创建了实例，空间换取时间，加载速度比较快。
【懒汉式-单例模式】在第一次调用获取对象的方法的时候才创建了实例，时间换空间，加载速度比较慢。
在多线程并发操作的时候【饿汉式-单例模式】的线程是安全的。但是对于【懒汉式-单例模式】线程是不安全的，有一定的几率会出现返回的对象不唯一，但是可以通过一些方式去规避风险。

后续有时间我将会对【懒汉式-单例模式】的线程的不安全性进行演示，同时分享相应的方法来规避该风险。