设计模式系列之一——单例模式几种实现方式

前言：要改变命运，首先要改变自己。

一、概述

设计模式代表了最佳的实践，是一套被反复使用，多数人知晓，经过分类编目，代码设计经验的总结。使用设计模式是为了重用代码，让代码更容易被人理解，保证代码可靠性。设计模式提供了软件开发过程中面临的一些问题的最佳解决方案，非常重要，主要分为创建型模式、结构型模式、创建型模式和J2EE 模式。

单例模式是设计模式中最简单的模式之一。这种类型的设计模式属于创建型设计模式，它提供了一种最佳创建对象的方式。所谓单例，就是保证整个程序有且仅有一个实例，负责创建自己的对象，同时保证只有一个对象被创建，向整个系统提供这个实例。这个类提供了一种访问其唯一的对象方式，可以直接访问，不需要实例化该类的对象。

注意：单例类只有一个实例，必须自己创建自己的唯一实例，给其他所有实例提供这个实例。

特点：

• 1.构造函数私有
• 2.持有自己类型的属性
• 3.对外提供获取实例的静态方法

优缺点：

• 优点：1.在内存中只有一个实例，节省内存空间；避免频繁创建销毁对象，提高性能；
•            2.避免对共享资源的多种占用，简化访问，为全局提供一个访问点。
• 缺点：1.不适用于变化频繁的对象；
•            2.没有接口，不能继承，与单一职责原则冲突，只关心内部逻辑，而不关心外部变化。

二、实例

单例模式有多种实现方式，如懒汉式，饿汉式，双重校验模式，静态内部类模式，枚举等。

1.懒汉模式

懒汉模式，顾名思义，比较“懒”，在需要用到的时候检查实例，有则直接返回，没有则才去创建，有线程安全和线程不安全两种写方法。

非线程安全：

//懒汉单例模式：非线程安全
public class LazySingleton {
    //唯一的实例
    private static LazySingleton mInstance;

    //私有构造方法，保证自己才可以创建实例
    private LazySingleton() {}

    //静态方法获取唯一可用的对象
    public static LazySingleton getInstance() {
        if (mInstance == null) {
            mInstance = new LazySingleton();
        }
        return mInstance;
    }
}

这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程，线程不安全的，因为没有加锁synchronized，严格意义上来说它不属于单例，这种方式lazy loading很明显，不要求线程安全，在多线程不能正常工作。

线程安全：

//懒汉模式：线程安全
public class LazySingleton {
    //唯一的实例
    private static LazySingleton mInstance;

    //私有构造方法，保证自己才可以创建实例
    private LazySingleton() {}

    //静态方法获取唯一可用的对象，synchronized加锁保证线程安全
    public static synchronized LazySingleton getInstance() {
        if (mInstance == null) {//保证单例的唯一性，在没有的时候才去创建
            mInstance = new LazySingleton();
        }
        return mInstance;
    }
}

加锁 synchronized这种方式很好具备lazy loading(懒加载)，线程安全，能都在多线程中很好的工作，但是效率比较低，绝大部分情况下不需要同步。双重锁模式更高效，下面讲解到。

2.饿汉模式

饿汉式，顾名思义，比较“饿”，在实例化的时候已经创建了，不管你有没有用到，都先建好实例再说，好处是没有加锁，效率较高，没有线程安全问题，坏处是容易产生垃圾对象，浪费内存。

//饿汉单例模式
public class HungerSingleton {
    //唯一的实例,实例化的时候直接创建
    private static HungerSingleton mInstance = new HungerSingleton();

    //私有构造方法，保证自己才可以创建实例
    private HungerSingleton() {}

    //静态方法获取唯一可用的对象
    public static HungerSingleton getInstance() {
        return mInstance;
    }
}

这种方式比较常用，但是极易产生垃圾对象，线程安全，没有加锁，效率比较高，就是类加载时就初始化了，浪费内存。它基于classloader机制避免了多线程问题，不过，instance在类加载时就实例化，虽然导致类装载的方法有很多中，在单例模式中大多数都是调用getInstance()，但是也不能确定有其他的方法（或者其他的静态方法）导致类装载，这时候初始化instance显然是没有到达lazy loading的效果。

3.双重锁模式

双重检锁是结合了懒汉式和饿汉式的优缺点整合而成，安全且在多线程情况下保证高性能。

//双检锁单例模式
public class Singleton {
    //唯一的实例
    private static Singleton mInstance;

    //私有构造方法，保证自己才可以创建实例
    private Singleton() {}

    //静态方法获取唯一可用的对象
    public static Singleton getInstance() {
        if (mInstance == null) {//为了不用每次获取对象都强制加锁，提升效率，判断不存在再加锁
            synchronized (Singleton.class) {//加锁，为了线程安全
                if (mInstance == null) {//保证单例的唯一性，在没有的时候才去创建
                    mInstance = new Singleton();
                }
            }
        }
        return mInstance;
    }    
}

这种方式采取双锁机制，特点是在synchronized内外都加上了一层if条件判断，这样既保证了线程安全，又比直接上锁提高了执行效率，还节省内存空间。

4.静态内部类模式

静态内部类单例模式其实是饿汉式的变种，利用jvm加载来保证线程安全，并且实现了懒加载，在需要用到的时候才去创建。

//静态内部类单例模式
public class StaticSingleton {
    //私有构造方法，保证自己才可以创建实例
    private StaticSingleton() {
    }

    //静态成员式内部类，该内部类实例与外部类实例没有绑定的关系，而且只有被调用时才会装载，从而实现延迟加载
    private static class innerSingleton {
        //静态初始化器，由jvm来保证线程安全
        private static final StaticSingleton instance = new StaticSingleton();
    }

    //静态方法获取唯一可用的对象
    public static StaticSingleton getInstance() {
        return innerSingleton.instance;
    }
}

static修饰的静态内部类，相当于外部类的静态成员变量，不与外部类实例产生依赖，静态内部类只可以应用外部类的静态成员和静态方法，只有在第一次使用到静态内部类时才会被装载。所以上述的实例instance在使用到时才被初始化。这种方式能到达双检锁一样的功效，但是实现更简单，对于静态域使用初始化，应该使用这种方式，而不是双检锁方式，这种使用于静态域的情况，双检锁方式可以在实例域延迟初始化使用。

静态内部类单例模式与饿汉式比较：

静态内部类单例模式同样利用了classloader来保证初始化instance只有一个线程，它与饿汉式不同的是，饿汉式只要Singleton类被装载，instance就会被初始化，没有达到 lazy loading的效果，而静态内部类单例模式是Singleton类被装载了，但是instance不一样被初始化，因为静态内部类innerSingleton没有被主动使用，而使用通过getInstance()方法显示去调用，才会转载innerSingleton类，从而初始化instance。如果实例化instance很耗资源，所以想让它延迟加载，不希望它在类实例化时就被初始化，因为不确定Singleton类还可能在其他地方被主动使用从而被加载，这时候初始化intance很不合适，这种方式比饿汉式就很合理了。

5.枚举

这种方式没有被广泛使用，但是这是单例模式的最佳方法，它更简洁，避免多线程同步问题，自动支持序列化机制，绝对防止多次实例化。

//枚举:这种方式没有被广泛使用，但是这是单例模式的最佳方法，它更简洁，避免多线程同步问题，自动支持序列化机制，绝对房子多次实例化。
public enum EnumSingleton {
    INSTANCE;
    public void getInstance(){
    }
}

它在JDK1.5之后才出现Enum，比较少用到。

我们来总结一下这几中的用法：

模式		说明	特点
单例模式： 保证整个程序有且仅有一个实例	懒汉式	需要用到才去检查实例，有则直接返回，无则直接创建	Lazy初始化，非线程安全，效率高，没有加锁
			Lazy初始化，线程安全，效率低，加锁
	饿汉式	在类初始化的时候已经创建实例	非Lazy初始化，线程安全，效率高，不加锁
	双检锁模式	采取双锁机制，在synchronized内外都加上了一层if条件判断	Lazy初始化，线程安全，效率高，加锁
	静态内部类模式	饿汉式的变种，static修饰的静态内部类，利用jvm加载来保证线程安全，并且实现了懒加载，需要用到的时才去创建实例	Lazy初始化，线程安全，效率高，不加锁
	枚举	特殊数据类型	简洁，避免多线程同步问题，自动支持列化机制，不常用

不建议使用第1种懒汉式，建议使用第2种饿汉式。只有在明确实现lazy loading效果时，才会使用第4种静态单例模式，如果涉及到反序列化创建对象时，可以尝试使用第5种枚举方式，如果有特殊需求，可以使用第3种双检锁模式。

至此，本文结束！

 

源码地址：https://github.com/FollowExcellence/JavaDesignMode

请尊重原创者版权，转载请标明出处：https://blog.csdn.net/m0_37796683/article/details/103203266 谢谢！