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

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

沉淀、分享、成长，让本身和他人都能有所收获！😄

1、前言

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

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

掌握了的知识才是本身的

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

书不是看的是用的

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

2、开发环境

1. JDK 1.8
2. Idea + Maven
3. 涉及工程1个，能够经过关注公众号：bugstack虫洞栈，回复源码下载获取(打开获取的连接，找到序号18)

3、单例模式介绍

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

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

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

4、案例场景

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

1. 数据库的链接池不会反复建立
2. spring中一个单例模式bean的生成和使用
3. 在咱们日常的代码中须要设置全局的的一些属性保存

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

5、7种单例模式实现

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

那么接下来咱们就经过实现不一样方式的实现进行讲解单例模式。

0. 静态类使用

public class Singleton_00 {

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

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

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

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。
• 目前此种方式的单例确实知足了懒加载，可是若是有多个访问者同时去获取对象实例你能够想象成一堆人在抢厕所，就会形成多个一样的实例并存，从而没有达到单例的要求。

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

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();
    }

}

• 此种模式虽然是安全的，但因为把锁加到方法上后，全部的访问都因须要锁占用致使资源的浪费。若是不是特殊状况下，不建议此种方式实现单例模式。

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

public class Singleton_03 {

    private static Singleton_03 instance = new Singleton_03();

    private Singleton_03() {
    }

    public static Singleton_03 getInstance() {
        return instance;
    }

}

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

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

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虚拟机能够保证多线程并发访问的正确性，也就是一个类的构造方法在多线程环境下能够被正确的加载。
• 此种方式也是很是推荐使用的一种单例模式

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

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;
    }

}

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

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

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也有一个缺点就是忙等，若是一直没有获取到将会处于死循环中。

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

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的最佳方法。

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

6、总结

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

7、推荐阅读

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