07.单例模式八板斧

发布时间：2023年12月24日

《孔乙己》里的孔乙己倔强的强调着“茴”字有四种写法；
《让子弹飞》里的武教头自称给黄四郎准备了九种死法；
《功夫》里的火云邪神不屑的嘲笑着飞来的子弹说“天下武功唯快不破”；

水有多深VS路有多长

前面几篇文章我们从宏观的角度拆解了设计模式的一些基本原则。对于设计模式的知识而言，此前所讲的那些原则只能说是开胃小菜，为什么这样说呢？因为23种设计模式我们今天才会开始拆解其中的第一种——单例模式。
我在最开始学习设计模式之前很长一段时间都有一种感受，大量的应用实例都给我一种自己是“孔乙己”的感觉。

“单例模式我知道啊，很基础的，我会用就可以了。什么？单例模式有八种写法？大哥，茴香豆的茴还有四种写法呢？你说这些有什么意义？白费功夫不是？”

其实这里夹杂着一个很重要的思考，就像我们玩桌游一定要先了解胜利的条件是什么一样。如果我现在问你，设计模式是什么？或者说为什么要学习了解设计模式？你出于什么样的目的想要学习设计模式？相信很多人可能一时不知从何说起。
设计模式这门学科在我目前的理解中，它更像是一种经验学，这恰恰是它独居魅力同时又极难真正吃透的原因。世界上最难的知识就是无字之书。

设计模式是程序员在面对同类软件工程设计问题所总结出来的有用的经验，模式不是代码，而是某类问题的通用解决方案，它真正代表的实际是一种最佳的实践。

这些方案是众多杰出的开发人员经过相当长的一段时间实验出来的。它的本意是要提高软件的维护性、通用性和扩展性同时降低软件的复杂度。最重要的是，它不受编程语言的限制，是真正的底层学科。下面就让我们一起踏上征程吧。

单例模式

概述

所谓单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态）。
比如Hibernate的SessionFactory,它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够，这时就会使用到单例模式。

实现单例模式的八种方式

饿汉式（静态常量，可能浪费内存）
饿汉式（静态代码块，可能浪费内存）
懒汉式（线程不安全）
懒汉式（线程安全，同步方法，效率低）
懒汉式（线程不完全安全，同步代码块，效率低）
双重检查
静态内部类
枚举

静态常量饿汉式

步骤

构造器私有化（防止new）
类的内部创建对象
向外暴露一个静态公共方法。（getInstance）

代码实现

/**
 * 单例模式 -
 *  饿汉式（静态变量）
 */
public class SingletonType1 {
    public static void main(String[] args) {
        //测试
        Singleton singleton = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton==singleton2);//是一个对象
    }
}

class  Singleton{
    //1.构造器私有化，外部不能new
    private Singleton(){
    }

    //2.在本类内部创建对象实例,在类初始化加载时就创建好一个实例（也是唯一一个实例）
    private final static Singleton instance = new Singleton();

    //3.提供一个共有的静态方法，返回实例对象即可
    public static Singleton getInstance(){
        return instance;
    }
}

分析

没什么安全风险，但是思考一个问题，类加载时就创建对象，如果自始至终都没有用过，不就浪费内存了嘛？这正是这种方式的显著缺点。

静态代码块饿汉式

代码实现

/**
 * 单例模式 -
 *  饿汉式（静态代码块）
 */
public class SingletonType2 {
    public static void main(String[] args) {
        //测试
        Singleton singleton = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton==singleton2);//是一个对象
    }
}

class  Singleton{
    //1.构造器私有化，外部不能new
    private Singleton(){
    }

    //2.在本类内部创建对象实例,在类初始化加载时就创建好一个实例（也是唯一一个实例）
    private  static Singleton instance;

    static {//在静态代码块中创建单例对象
        instance = new Singleton();
    }

    //3.提供一个共有的静态方法，返回实例对象即可
    public static Singleton getInstance(){
        return instance;
    }
}

分析

同样没有什么安全风险，但是并没有解决可能的内存浪费问题。

放飞自我懒汉式

代码实现

/**
 * 单例模式 - 懒汉式 - 线程不安全
 */
public class SingletonTest3 {
    public static void main(String[] args) {
        //测试
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton==singleton1);
    }
}

//单例模式 - 懒汉式 - 线程不安全
class Singleton{

    private static Singleton instance;

    private Singleton(){
    }

    //提供一个静态的共有方法，当使用改方法时，才去创建instance
    //即懒汉式
    public static Singleton getInstance(){
        if (instance==null)
            instance = new Singleton();
        return instance;
    }
}

分析

确实是有lazy loading的效果，但是相信有同学已经看出来了，它是线程不安全的，除非是单线程场景，否则绝对不能用。

谨小慎微懒汉式

代码实现

/**
 * 单例模式 - 懒汉式 - 线程安全(同步方法)
 */
public class SingletonTest4 {
    public static void main(String[] args) {
        //测试
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton==singleton1);
    }
}

//单例模式 - 懒汉式 - 线程安全
class Singleton{
    private static Singleton instance;

    private Singleton(){
    }

    //提供一个静态的共有方法，当使用改方法时，才去创建instance
    //加入同步处理，防止线程不安全
    //即懒汉式
    public static synchronized Singleton getInstance(){
        if (instance==null)
            instance = new Singleton();
        return instance;
    }
}

分析

直接一刀切，确实线程安全了，效率太低了。

恶意 All In 懒汉式

代码实现

/**
 * 单例模式 - 懒汉式 - 线程不安全(同步代码块) - 效率低
 */
public class SingletonTest5 {
    public static void main(String[] args) {
        //测试
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton==singleton1);
    }
}

//单例模式 - 懒汉式 - 线程不安全
class Singleton{
    private static Singleton instance;
    private Singleton(){

    }
    //提供一个静态的代码块，当使用改方法时，才去创建instance
    //虽然加入同步代码块，但是线程依然不安全
    //即懒汉式
    public static synchronized Singleton getInstance(){
        if (instance==null){
            synchronized (Singleton.class){
                instance = new Singleton();
            }
        }
        return instance;
    }
}

分析

本想结合效率和线程问题搞个all in，但是这种同步并不能起到线程同步的作用。

双重检查实现单例

代码实现

/**
 * 单例 - 双重检查方式实现
 */
public class SingletonTest6 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton1 = Singleton.getInstance();
        System.out.println(singleton==singleton1);
    }
}

class Singleton{

    //volatile关键字，可以让修改值立即更新到主存，可以理解为是轻量级的synchronized
    private static volatile Singleton instance;

    private Singleton(){

    }

    //提供一个静态公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
    public static Singleton getInstance(){
        if (instance==null){
            synchronized (Singleton.class){
                if (instance==null)
                    instance = new Singleton();
            }
        }
        return instance;
    }
}

分析

double-check，多线程经常用到的理论，线程安全效率也很高。

静态内部类实现单例

代码实现

/**
 * TO DO
 * 单例 - 静态内部类实现方式
 * @author Wayne
 * @date 2022/11/10 21:23
 */
public class SingletonTest7 {
}

class Singleton{
    private Singleton(){
    }
    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

分析

当Singleton类装载时，其内部类不会装载；
当调用getInstance方法用到了静态内部类时，才会装载静态内部类；
当类装载时是线程安全的，且每个类只会被装载一次。
懒汉式，线程安全稳定高效

枚举实现单例

代码实现

/**
 * TO DO
 *  枚举方式实现单例
 * @author Wayne
 * @date 2022/11/1021:48
 */
public class SingletonTest8 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.INSTANCE;
        Singleton singleton1 = Singleton.INSTANCE;
        System.out.println(singleton==singleton1);
    }
}

enum Singleton{
    INSTANCE;//属性
    public void sayOk(){
        System.out.println("ok~");
    }
}

分析

借助JDK1.5的枚举特性实现单例，不仅避免了多线程问题，还能防止反序列化重复创建对象。

人生这场养成游戏里，我们都是主角

一通写完，打个小结，单例模式八板斧，实际推荐使用的只有后三个。那么反思时刻又来了，你浪费键盘敲了一上午写前五个干什么，你不就是孔乙己吗？
是啊，这也是我时常问自己的问题，在实际工作中各种框架技术早已完备的开箱即用且不说，就是真的要你写一个单例模式，也是要求你最快实现就可以了，哪个还有耐心听你一板一眼的分析我是从八个里面选了最好的一个呢？
最近董宇辉和东方甄选的纷争想必大家也都有耳闻，董老师在这场漩涡中心的时候说了这样一句话：“读书人就是拧巴。”
其实不是读书人拧巴，而是人生这场养成游戏并没有给所有人很高的掉宝率。好机会可能在一辈子只能出现一两次，它不会问你是否准备好，错过了就是错过了。不要在最关键的时候抱怨“书到用时方恨少”，这场游戏里我们每个人都是主角，最后存档的时候不让自己遗憾才是最重要的。

关注我，共同进步，每周至少一更。讲的不只是代码。——Wayne

文章来源:https://blog.csdn.net/WayneSlytherin/article/details/135173420
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！