重学-Java-设计模式实战单例模式

38次阅读

共计 4834 个字符，预计需要花费 13 分钟才能阅读完成。

作者：小傅哥
博客：https://bugstack.cn

沉淀、分享、成长，让自己和他人都能有所收获！?

5 个创建型模式的最后一个

在设计模式中按照不同的处理方式共包含三大类；创建型模式 、 结构型模式 和行为模式 ，其中创建型模式目前已经介绍了其中的四个； 工厂方法模式 、 抽象工厂模式 、 生成器模式 和原型模式 ，除此之外还有最后一个 单例模式。

掌握了的知识才是自己的

在本次编写的 重学 Java 设计模式 的编写中尽可能多的用各种场景案例还介绍设计的使用，包括我们已经使用过的场景；各种类型奖品发放 、 多套 Redis 缓存集群升级 、 装修公司报价清单 和百份考卷题目与答案乱序，通过这些场景案例的实践感受设计模式的思想。但这些场景都是作者通过经验分离出来的，还并不是读者的知识，所以你如果希望可以融会贯通的掌握那么一定要亲力亲为的操作，事必躬亲的完成。

书不是看的是用的

在这里还是想强调一下学习方法，总有很多小伙伴对学习知识有疑惑，明明看了、看的时候也懂了，但到了实际使用的时候却用不上。或者有时候在想是不要是有更加生动的漫画或者什么对比会好些，当然这些方式可能会加快一个新人对知识的理解速度。但只要你把学习视频当电影看、学习书籍当故事看，就很难掌握这项技术栈。只有你把它用起来，逐字逐句的深挖，一点点的探求，把各项遇到的盲点全部扫清，才能让你真的掌握这项技能。

JDK 1.8
Idea + Maven
涉及工程 1 个，可以通过关注 公众号 ：bugstack 虫洞栈，回复 源码下载 获取(打开获取的链接，找到序号 18)

单例模式可以说是整个设计中最简单的模式之一，而且这种方式即使在没有看设计模式相关资料也会常用在编码开发中。

因为在编程开发中经常会遇到这样一种场景，那就是需要保证一个类只有一个实例哪怕多线程同时访问，并需要提供一个全局访问此实例的点。

综上以及我们平常的开发中，可以总结一条经验，单例模式主要解决的是，一个全局使用的类频繁的创建和消费，从而提升提升整体的代码的性能。

本章节的技术所出现的场景非常简单也是我们日常开发所能见到的，例如；

数据库的连接池不会反复创建
spring 中一个单例模式 bean 的生成和使用
在我们平常的代码中需要设置全局的的一些属性保存

在我们的日常开发中大致上会出现如上这些场景中使用到单例模式，虽然单例模式并不复杂但是使用面却比较广。

单例模式的实现方式比较多，主要在实现上是否支持懒汉模式、是否线程安全中运用各项技巧。当然也有一些场景不需要考虑懒加载也就是懒汉模式的情况，会直接使用 static 静态类或属性和方法的方式进行处理，供外部调用。

那么接下来我们就通过实现不同方式的实现进行讲解单例模式。

public class Singleton_00 {public static Map<String,String> cache = new ConcurrentHashMap<String, String>();
    
}

以上这种方式在我们平常的业务开发中非常场常见，这样静态类的方式可以在第一次运行的时候直接初始化 Map 类，同时这里我们也不需要到延迟加载在使用。
在不需要维持任何状态下，仅仅用于全局访问，这个使用使用静态类的方式更加方便。
但如果需要被继承以及需要维持一些特定状态的情况下，就适合使用单例模式。

public class Singleton_01 {

    private static Singleton_01 instance;

    private Singleton_01() {}

    public static Singleton_01 getInstance(){if (null != instance) return instance;
        return new Singleton_01();}

}

单例模式有一个特点就是不允许外部直接创建，也就是new Singleton_01()，因此这里在默认的构造函数上添加了私有属性 private。
目前此种方式的单例确实满足了懒加载，但是如果有多个访问者同时去获取对象实例 你可以想象成一堆人在抢厕所，就会造成多个同样的实例并存，从而没有达到单例的要求。

public class Singleton_02 {

    private static Singleton_02 instance;

    private Singleton_02() {}

    public static synchronized Singleton_02 getInstance(){if (null != instance) return instance;
        return new Singleton_02();}

}

此种模式虽然是安全的，但由于把锁加到方法上后，所有的访问都因需要锁占用导致资源的浪费。如果不是特殊情况下，不建议此种方式实现单例模式。

public class Singleton_03 {private static Singleton_03 instance = new Singleton_03();

    private Singleton_03() {}

    public static Singleton_03 getInstance() {return instance;}

}

此种方式与我们开头的第一个实例化 Map 基本一致，在程序启动的时候直接运行加载，后续有外部需要使用的时候获取即可。
但此种方式并不是懒加载，也就是说无论你程序中是否用到这样的类都会在程序启动之初进行创建。
那么这种方式导致的问题就像你下载个游戏软件，可能你游戏地图还没有打开呢，但是程序已经将这些地图全部实例化。到你手机上最明显体验就一开游戏内存满了，手机卡了，需要换了。

public class Singleton_04 {

    private static class SingletonHolder {private static Singleton_04 instance = new Singleton_04();
    }

    private Singleton_04() {}

    public static Singleton_04 getInstance() {return SingletonHolder.instance;}

}

使用类的静态内部类实现的单例模式，既保证了线程安全有保证了懒加载，同时不会因为加锁的方式耗费性能。
这主要是因为 JVM 虚拟机可以保证多线程并发访问的正确性，也就是一个类的构造方法在多线程环境下可以被正确的加载。
此种方式也是非常推荐使用的一种单例模式

public class Singleton_05 {

    private static Singleton_05 instance;

    private Singleton_05() {}

    public static Singleton_05 getInstance(){if(null != instance) return instance;
       synchronized (Singleton_05.class){if (null == instance){instance = new Singleton_05();
           }
       }
       return instance;
    }

}

双重锁的方式是方法级锁的优化，减少了部分获取实例的耗时。
同时这种方式也满足了懒加载。

public class Singleton_06 {private static final AtomicReference<Singleton_06> INSTANCE = new AtomicReference<Singleton_06>();

    private static Singleton_06 instance;

    private Singleton_06() {}

    public static final Singleton_06 getInstance() {for (; ;) {Singleton_06 instance = INSTANCE.get();
            if (null != instance) return instance;
            INSTANCE.compareAndSet(null, new Singleton_06());
            return INSTANCE.get();}
    }

    public static void main(String[] args) {System.out.println(Singleton_06.getInstance()); // org.itstack.demo.design.Singleton_06@2b193f2d
        System.out.println(Singleton_06.getInstance()); // org.itstack.demo.design.Singleton_06@2b193f2d
    }

}

java 并发库提供了很多原子类来支持并发访问的数据安全性；AtomicInteger、AtomicBoolean、AtomicLong、AtomicReference。
AtomicReference<V> 可以封装引用一个 V 实例，支持并发访问如上的单例方式就是使用了这样的一个特点。
使用 CAS 的好处就是不需要使用传统的加锁方式保证线程安全，而是依赖于 CAS 的忙等算法，依赖于底层硬件的实现，来保证线程安全。相对于其他锁的实现没有线程的切换和阻塞也就没有了额外的开销，并且可以支持较大的并发性。
当然 CAS 也有一个缺点就是忙等，如果一直没有获取到将会处于死循环中。

public enum Singleton_07 {

    INSTANCE;
    public void test(){System.out.println("hi~");
    }

}

约书亚·布洛克（英语：Joshua J. Bloch，1961 年 8 月 28 日-），美国著名程序员。他为 Java 平台设计并实作了许多的功能，曾担任 Google 的首席 Java 架构师（Chief Java Architect）。

Effective Java 作者推荐使用枚举的方式解决单例模式，此种方式可能是平时最少用到的。
这种方式解决了最主要的；线程安全、自由串行化、单一实例。

调用方式

@Test
public void test() {Singleton_07.INSTANCE.test();

这种写法在功能上与共有域方法相近，但是它更简洁，无偿地提供了串行化机制，绝对防止对此实例化，即使是在面对复杂的串行化或者反射攻击的时候。虽然这中方法还没有广泛采用，但是单元素的枚举类型已经成为实现 Singleton 的最佳方法。

但也要知道此种方式在存在继承场景下是不可用的。

虽然只是一个很平常的单例模式，但在各种的实现上真的可以看到 java 的基本功的体现，这里包括了；懒汉、饿汉、线程是否安全、静态类、内部类、加锁、串行化等等。
在平时的开发中如果可以确保此类是全局可用不需要做懒加载，那么直接创建并给外部调用即可。但如果是很多的类，有些需要在用户触发一定的条件后 (游戏关卡) 才显示，那么一定要用懒加载。线程的安全上可以按需选择。
建议在学习的过程中一定要加以实践，否则很难完完整整的掌握一整套的知识体系。例如案例中的出现的 Effective Java 一书也非常建议大家阅读。另外推荐下这位大神的 Github：https://github.com/jbloch

重学 Java 设计模式：实战原型模式- 模拟考试试卷乱序题目和答案
Java 开发架构篇：初识领域驱动设计 DDD 落地
Java 开发架构篇：DDD 模型领域层决策规则树服务设计
Java 开发架构篇：领域驱动设计架构基于 SpringCloud 搭建微服务
源码分析(面试常问题目) | Mybatis 接口没有实现类为什么可以执行增删改查
讲道理，只要你是一个爱折腾的程序员，毕业找工作真的不需要再花钱培训！

正文完

设计模式

发表至：设计模式

2020-06-01

0

笔记设计模式5提高代码质量

设计模式之美二-面向对象1

关于设计模式:你有原则么懂原则么想了解么快看设计模式原则篇让你做个有原则的程序员

关于设计模式:20-设计模式责任链模式

记一次-Angular-基于-STOMP-over-WebSocket-实现流文本传输

重学-Java-设计模式实战单例模式

一、前言

二、开发环境

三、单例模式介绍

四、案例场景

五、7 种单例模式实现

0. 静态类使用

1. 懒汉模式(线程不安全)

2. 懒汉模式(线程安全)

3. 饿汉模式(线程安全)

4. 使用类的内部类(线程安全)

5. 双重锁校验(线程安全)

6. CAS「AtomicReference」(线程安全)

7. Effective Java 作者推荐的枚举单例(线程安全)

六、总结

七、推荐阅读

Just My Socks（注册教程内含优惠码）

重学-Java-设计模式实战单例模式

一、前言

二、开发环境

三、单例模式介绍

四、案例场景

五、7 种单例模式实现

0. 静态类使用

1. 懒汉模式(线程不安全)

2. 懒汉模式(线程安全)

3. 饿汉模式(线程安全)

4. 使用类的内部类(线程安全)

5. 双重锁校验(线程安全)

6. CAS「AtomicReference」(线程安全)

7. Effective Java 作者推荐的枚举单例(线程安全)

六、总结

七、推荐阅读

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）