Java23种设计模式之单例模式

---

前言

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

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

---

一、单例模式特点

下面我们来一张比较有意思的图说明：

这样单例模式保证一个类只有一个实例，减少了内存开销，尤其是那种频繁的创建和摧毁的场景，避免了对资源的多重占用，比如文件IO操作。

二、单例模式的优点

1、在内存里只有一个实例，减少了内存开销，尤其是那种频繁的创建和摧毁的场景。

2、避免对资源的多重占用，比如文件操作。

三、单例模式的缺点

1、没有接口，不能被继承，违背了单一职责设计原则，一个类应该只关心其内部业务逻辑，而不关心外部怎么实例化。

2、 该模式在多线程环境下需要进行特殊处理， 避免多个线程多次创建单例对象。

3、单例的客户端代码单元测试可能会比较困难， 因为许多测试框架以基于继承的方式创建模拟对象。 由于单例类的构造函数是私有的， 而且绝大部分语言无法重写静态方法， 所以你需要想出仔细考虑模拟单例的方法。 要么干脆不编写测试代码， 或者不使用单例模式。

四、饿汉式单例模式

首先创建单例模式类，私有化构造方法，一来就创建一个单例对象，表示很饥饿。

/**
 * @description: 单列模式
 * @author: dt
 * @date: 2021/4/5 12:16
 * @version: v1.0
 */
public class Hungry {

    /**
     * 让构造函数为 private，这样该类就不会被实例化
     */
    private Hungry() {
    }

    /**
     * 创造一个静态单例对象
     */
    private final static Hungry HUNGRY = new Hungry();

    /**
     * 获取唯一可用的对象
     * @return
     */
    public static Hungry getInstance(){
        return HUNGRY;
    }

    public void showMessage(){
        System.out.println("Hello World!");
    }
}

获取单例对象实例：

 public static void main(String[] args) {

        // 不可用被实例化,编译直接报错
        // Hungry hungry = new Hungry();

        // 获取唯一可用对象
        Hungry hungry = Hungry.getInstance();
        hungry.showMessage();

    }

但是这样的饿汉式模式是有问题的，会产生什么问题呢？

假设这里有四组资源，是非常耗内存的，浪费空间，我们应该在使用的时候再去加载，于是乎就有了懒汉式单列模式。

/**
 * @description: 单列模式
 * @author: dt
 * @date: 2021/4/5 12:16
 * @version: v1.0
 */
public class Hungry {


    /**
     * 假设这里有四组资源，是非常耗内存的，浪费空间，我们应该在使用的时候再去加载
     */
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];

    /**
     * 让构造函数为 private，这样该类就不会被实例化
     */
    private Hungry() {
    }

    /**
     * 创造一个单例对象
     */
    private final static Hungry HUNGRY = new Hungry();

    /**
     * 获取唯一可用的对象
     * @return
     */
    public static Hungry getInstance(){
        return HUNGRY;
    }

    public void showMessage(){
        System.out.println("Hello World!");
    }
}

五、懒汉式单例模式

/**
 * @description: 懒汉式单列模式
 * @author: ydf
 * @date: 2021/4/12 21:47
 * @version: v1.0
 */
public class LazyMan {

    private LazyMan(){
        System.out.println(Thread.currentThread().getName());
    }

    public static LazyMan lazyMan;

    public static LazyMan getInstance(){
        // 不为null，我们才使用实例对象
        if(lazyMan==null){
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }

    // 单线程下单列模式可以运行的，完全没问题，如果并发条件下就有问题了

    // 测试并发条件
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                LazyMan.getInstance();
            }).start();
        }
    }
}

打印结果：

单线程下单列模式可以运行的，完全没问题，如果并发条件下就有问题了。那么怎么解决呢？

加锁控制：双重检测锁模式

/**
 * @description: 懒汉式单列模式
 * @author: ydf
 * @date: 2021/4/12 21:47
 * @version: v1.0
 */
public class LazyMan {

    private LazyMan(){
        System.out.println(Thread.currentThread().getName());
    }

    private volatile static LazyMan lazyMan;

    public static LazyMan getInstance(){
        // 加锁，双重检测一下
        if(lazyMan == null){
            synchronized (LazyMan.class){
                if(lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }

    // 单线程下单列市客运的，如果并发条件下就有问题了

    // 测试并发条件
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                LazyMan.getInstance();
            }).start();
        }
    }
}

通过观察我们可以看到通过双重检测锁，保证了线程对象的唯一，测试成功。

总结

1、执行效率上：饿汉式没有加任何的锁，因此执行效率比较高。懒汉式一般使用都会加同步锁，效率比饿汉式差。

2、性能上：饿汉式在类加载的时候就初始化，不管你是否使用，它都实例化了，所以会占据空间，浪费内存。懒汉式什么时候需要什么时候实例化，相对来说不浪费内存。

3、饿汉式： 在类加载时就初始化创建单例对象，线程安全，但不管是否使用都创建对象可能会浪费内存。
4、懒汉式： 在外部调用时才会加载，线程不安全，可以加锁保证线程安全但效率低。