蓦然回头-单例模式篇章一

Posted 2021-01-19 sunyk

单例模式整理

敲了多年代码后，回头来看会别有一番滋味在心头。。

概念

单例模式是为了保证在一个jvm环境下，一个类仅有一个对象。

代码中常见的懒汉式。饿汉式，这些实现方式可以通过代码的设计来强制保证的单例，也可以通过文档，通过编码约束，可以认为是一个类仅有一个对象。

代码场景

项目中被封装到底层的连接功能的类，数据库连接，socket连接，具有配置功能的类，工具类，辅助系统类，会需要使用单例模式。这些类的特点：是创建和销毁需要消耗大量的系统资源，或者不需要创建多个对象。

实战

单例1，饿汉式

/**
 * 最常见的单例，有两个必不可少的东西
 * 1.私有化类的所有构造函数，以阻止其他代码在该类的外界去创建对象
 * 2.提供获取对象的静态方法，以返回类唯一的对象引用
 *
 * @author sunyang
 * @date 2018/11/6 18:44
 */
//单例1，通过类的静态变量来持有一个该类的对象的引用，同时使用final关键字来阻止被再次赋值
public class Singleton1 {

    private final static Singleton1 INSTANCE = new Singleton1();

    public Singleton1() {
    }

    public static Singleton1 getINSTANCE() {
        return INSTANCE;
    }
}

单例2，饿汉式

/**
 * 单例2，是使用静态变量维护该类的引用，但是要将对象创建放在静态代码块中
 *
 * @author sunyang
 * @date 2018/11/6 18:49
 */
public class Singleton2 {
    private static final Singleton2 INSTANCE;

    static {
        INSTANCE = new Singleton2();
    }

    public Singleton2() {
    }

    public static Singleton2 getInstance(){
        return INSTANCE;
    }


}

单例3，懒汉式

/**
 * 单例3，使用静态变量维持类的对象引用，在获取对象的方法中对象进行判断和创建
 *
 * @author sunyang
 * @date 2018/11/6 18:59
 */
public class Singleton3 {
    public static Singleton3 instance;

    private Singleton3(){

    }

    private static Singleton3 getInstance(){
        if (instance == null){
            instance = new Singleton3();
        }
        return instance;
    }

}

分析

单例1和单例2，将对象创建放在类的初始化阶段，单例3则是将对象的创建放在类的使用阶段。

所以，单例1和单例2称为饿汉式，单例3称为懒汉式。优缺点：

饿汉式的优点是简单易懂，缺点是没有达到懒加载的效果。如果整个生命周期中自始至终未使用过这个实例，就会比较浪费连接资源和内存。

懒汉式并不复杂，可以起到懒加载的效果。于是，实际开发中更愿意使用懒汉式，因为节省内存，懒加载。

联想

类的生命周期：

1.类的加载：

将类的字节码文件.class从硬盘载入方法区的过程

2.类的连接：

该过程由三个部分组成：验证、准备和解析

3.类的初始化：

将静态变量赋值，执行的顺序就是，

父类静态变量->静态代码块->子类静态变量->子类静态代码块

饿汉式的对象创建在这个阶段

4.类的使用：

类的实例化，懒汉式的对象创建处于这个阶段，new关键字可以触发该生命周期

5.类卸载

验证

/**
 * 如果验证？
 * 根据类的五个生命周期阶段，我们只需要验证在创建对象之前的
 * 那些操作能够触发类的初始化就行。
 *
 * @author sunyang
 * @date 2018/11/8 11:13
 */
public class ValidSingleton1 {
    /**
     * 首先在构造方法里添加打印语句，打印"init"
     * 再添加静态方法和一个静态变量
     *
     */
    private static final ValidSingleton1 INSTANCE = new ValidSingleton1();

    //打印init
    public ValidSingleton1() {
        System.out.println("init");
    }

    public static ValidSingleton1 getINSTANCE() {
        return INSTANCE;
    }
    //静态方法
    public static final void otherMethod(){

    }
    //静态变量
    public static final int staticField = 0;
}

开始验证

/**
 * @author sunyang
 * @date 2018/11/8 11:26
 */
public class ValidSingletonDemo {

    public static void main(String[] args) {
        System.out.println("---------------------start");
        /*1.验证单例1,只声明，不会触发类的初始化阶段
        ValidSingleton1 validSingleton1 = null;
        if (null == validSingleton1){
            System.out.println("singleton1 is null");
        }*/
        /*//2.调用类的静态变量
        System.out.println(ValidSingleton1.staticField);*/

        //3.调用类的静态方法
//        ValidSingleton1.otherMethod();
        //4.初始化两次
        ValidSingleton1 validSingleton1 = new ValidSingleton1();
        //5.直接调用
//        ValidSingleton1.getINSTANCE();
        System.out.println("---------------------end");

        /**
         * -------start-------
         * singleton1 is null
         * -------end---------
         *
         * ---------------------start
         *  0
         *   ---------------------end
         *
         *   ---------------------start
         *  init
         *  ---------------------end
         *
         *  ---------------------start
         *  init
         *  init
         *  ---------------------end
         *
         *
         *  ---------------------start
         * init
         * ---------------------end
         */
    }
}

从输出上看，调用类的静态方法以下，会触发类的初始化阶段。

发现饿汉式，是不会产生线程安全的问题；

在设计上，懒汉式要优于饿汉式

关联线程安全

在多线程下，懒汉式会有一定修改。当两个线程在if(null == instance)语句阻塞的时候，可能由两个线程进入创建实例，从而返回了两个对象。对此，我们可以加锁，保证仅有一个线程处于getInstance（）方法中，从而保证了线程一致性。多线程下的单例

/**
 * @author sunyang
 * @date 2018/11/8 12:18
 */
public class Singleton4 {

    private static Singleton4 instance;

    private Singleton4(){

    }
    //需要加上synchronized 同步
    public static synchronized Singleton4 getInstance(){
        if (instance == null){
            instance = new Singleton4();
        }
        return instance;
    }
}