肝一肝设计模式【一】-- 单例模式网站首页 技术交流

肝一肝设计模式【一】-- 单例模式

掩护那个写后端的 2023-06-11 00:00:03

简介肝一肝设计模式【一】-- 单例模式

我记得我刚学编程的时候，就听过设计模式的大名，当时总觉得这东西应该离我很远，所以就一直选择性的躲开这部分内容，直到在开始工作时，遇到比较复杂的业务，才正式的接触设计模式，也是在那个时候才知道设计模式有多重要，它对于开发者来说有多香，谁用谁知道，所以无论你是菜鸟还是老鸟，早点了解设计模式之美，都会对你的学习或者工作，有事半功倍的帮助。

系列文章目录

肝一肝设计模式【一】-- 单例模式传送门

文章目录

系列文章目录
前言
一、概述
- 1. 设计模式有哪些
- 2. 设计模式的原则有哪些
二、单例模式（Singleton）
写在最后

前言

设计模式，Design Pattern，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易地被他人理解、保证代码可靠性。毫无疑问，设计模式于己于人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石脉络，如同大厦的结构一样。

一、概述

1. 设计模式有哪些

设计模式主要分为三大类，共23种：

创建型模式（5种）：
单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式
结构型模式（7种）：
适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式
行为型模式（11种）：
策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式

2. 设计模式的原则有哪些

开闭原则：
开闭原则说的是，对扩展开放、对修改关闭。在程序需要进行扩展的时候，不能去修改原有的代码，这也是为了使程序的扩展性更好、易于升级和维护
单一职责原则
单一职责原则是指不要存在多于一个导致类变更的原因，一个类、接口或方法只负责一项职责，这样的设计，可以降低类的复杂度，提高类的可读性，提高系统的可维护性，降低变更引起的风险
里氏代换原则：
在软件中将一个基类对象替换成它的子类对象，程序将不会产生任何错误和异常，反过来则不成立。如果一个软件实体使用的是一个子类对象的话，那么它一定不能够使用基类对象。里氏代换原则的程序表现就是：在程序中尽量使用基类类型来对对象进行定义，而在运行时再确定其子类类型，用子类对象来替换父类
依赖倒转原则：
针对接口编程，依赖于抽象而不依赖于具体
接口隔离原则：
使用多个隔离的接口，比使用单个接口要好
迪米特法则：
一个实体应当尽量少地与其他实体间发生相互作用，使得系统功能模块相对独立
合成复用原则：
尽量使用组合/聚合的方式，而不是使用继承

二、单例模式（Singleton）

单例模式是各个Java项目中必不可少的一种设计模式，那什么是单例模式呢，保证一个系统中的某个类只有一个实例而且该实例易于外界访问，那这个类就称为单例类。

单例模式有以下特点：

单例类只能有一个实例
单例类必须自己创建自己的唯一实例
单例类必须给其他所有对象提供这一实例

1. 饿汉式

顾名思义，饿汉式，就是使用类的时候不管用的是不是类中的单例部分，都直接创建出单例类，看一下一种比较常见的饿汉式写法。

定义一个私有的构造方法，并将自身的实例对象设置为一个私有属性，并加上static和final修饰符，然后通过公共的静态方法调用返回实例。

class HungrySingleton {

    private HungrySingleton() {
    }
    
    private static final HungrySingleton instance = new HungrySingleton();

    public static HungrySingleton getInstance() {
        return instance;  
    }
}

这种写法会不会造成竞争，引发线程安全问题呢？

答案是不会。

可能有人会觉得奇怪，线程A，实例化一个HungrySingleton，没有实例化完，CPU就从线程A切换到线程B了，线程B此时也实例化这个HungrySingleton，这样不就被实例化出来了两次，有两份内存地址了吗，不就有线程安全问题了吗？

没关系，这个问题我们完全不需要担心，JDK已经帮我们想到了，JVM采用了CAS配上失败重试的方式和TLAB两种方式来解决这个问题。

2. 懒汉式

同样的，顾名思义，这个人比较懒，只有当单例类用到的时候才会去创建这个单例类，看一下懒汉式的写法：

定义一个私有的构造方法，定义一个该类静态私有的变量，然后定义一个公共的静态方法，对该类的值进行空判断，不为空直接返回，否则重新构建一个。

class LazySingleton {

     private LazySingleton() {
     }
     
     private static LazySingleton instance;

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

这种写法是一种线程非安全的写法。

比如线程A初次调用getInstance()方法，此时CPU切换到线程B，看到instance是null，就new了一个LazySingleton出来，这时切换回线程A，看到instance是null，也new了一个LazySingleton出来。这样，单例类LazySingleton在内存中就有两份引用了，这就违背了单例模式的本意了。

所以为了解决这个问题，还有两种写法：静态内部类和双检锁。

3. 静态内部类

class LazySingleton {

     private LazySingleton(){
     }
	    
     private static class InnerLazySingleton{
         private static LazySingleton instance = new LazySingleton();
     }
	  
     public static final LazySingleton getInstance(){
         return InnerLazySingleton.instance;
     }
 }

这种写法是因为该类的内部类是私有的，除了对外公布的公共静态方法getInstance()以外，其他人是无法访问的。因为它是延迟加载，所以读取实例的时候不会进行同步，几乎没有性能的缺陷，而且还是线程安全的，并且不依赖JDK的版本。

4. 双检锁

除了上面的写法，还可以用给getInstance()方法加锁的写法，但是又不需要给全部方法都加锁，只需要给方法的一部分加锁就好了，所以基于这个考虑，引入了双检锁（Double Check Lock，简称DCL）的写法：

class DoubleCheckLockSingleton{

     private static volatile DoubleCheckLockSingleton instance;
        
     private DoubleCheckLockSingleton(){
     }
     
     public static DoubleCheckLockSingleton getInstance(){
         if (instance == null) {
             synchronized (DoubleCheckLockSingleton.class) {
                 if (instance == null) {
                     instance  = new DoubleCheckLockSingleton();
                 }
             }
         }
         return instance;
     }
 }

通过volatile定义静态私有变量，保证了该变量的可见性，然后定义一个共有的静态方法，第一次对该对象实例化时与否判断，不为空直接返回，提升效率；然后使用synchronized 进行同步代码块，防止对象未初始化时，在多线程访问该对象在第一次创建后，再次重复的被创建；然后第二次对该对象实例化时与否判断，如果未初始化，则初始化，否则直接返回该实例。