知了堂学习笔记--Java设计模式之单例模式_java里的abstract写单例-CSDN博客

本文链接：https://blog.csdn.net/abstract_yt/article/details/79153532

请关注知了堂学习社区：知了学习
概念：
　　java中单例模式是一种常见的设计模式，它通过阻止外部实例化和修改，来控制所创建的对象的数量。单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、枚举。
　　单例模式有以下特点：
　　1、单例类只能有一个实例。
　　2、单例类必须自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。
　　实例：在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常等等都被设计成单例

一、懒汉式模式

1. 传统懒汉模式

//传统懒汉模式，非线程安全
public class Singleton01 {
    private Singleton01() {};
    private static Singleton01 singleton01 = null;
    public static Singleton01 getInstance() {
        if(singleton01 == null) {
            singleton01 = new Singleton01();
        }
        return singleton01;
    }
}

通过将构造方法限定为private避免了类在外部被实例化，事实上：Java中存在反射机制(可以动态的获取子类的全部方法，属性)存在，基本上所有的单例都会失效。
线程不安全,并发环境下很可能出现多个Singeton01实例，要实现线程安全，我们可以对getInstance()这个方法改造，保证了懒汉式单例的线程安全,有以下三种方式：

2. 同步懒汉模式

//同步懒汉模式
public class Singleton02 {
    private Singleton02() {};
    private static Singleton02 singleton02 = null;
    //在传统懒汉模式基础上加上同步，线程安全。每次只能唯一操作
    public static synchronized Singleton02 getInstance() {
        if(singleton02 == null) {
            singleton02 = new Singleton02();
        }
        return singleton02;
    }
}

在传统懒汉模式上加上同步锁，可以控制唯一操作该单例，同步比较耗资源，效率低，如果多个请求，可能会出现卡死现象
3. 双层判断锁定

//双层判断锁定
public class Singleton03 {
    private Singleton03() {};
    private static Singleton03 singleton03 = null;
    //综合上面两张方法，因为同步比较耗资源，所以需要先判断，在同步。节约资源
    public static Singleton03 getInstance() {
        if(singleton03 == null) {
            synchronized (Singleton03.class){
                singleton03 = new Singleton03();
            }
        }
        return singleton03;
    }
}

同步锁比较耗资源，所以同步之前加上一个判断。
4. 静态内部类

//静态内部类
public class Singleton04 {
    private Singleton04() {};
    private static class Singleton {
        private static final Singleton04 singleton04 = new Singleton04();
    }
    public static final Singleton04 getInstance() {
        return Singleton.singleton04;
    }
}

静态内部类只在外部内可见。静态实现了线程安全，内部类解决了同步带来的性能影响。
使用static可以试内部类脱离外部类的实例对象（嵌套类），可以理解成一个全新的类吧，类该有的它都具有。静态内部类对外是不可见的，只在外部类内部可见，所以线程安全很高。
以上四种方法，线程的安全性有低到高，第四种，既实现了线程安全，又避免了同步带来的性能影响。

二、饿汉模式

在类创建是唯一实例化自己，以后都不改变，天生线程安全

饿汉模式

//饿汉模式，私有化构造方法，并提供唯一自己实例
public class E_han01 {
    private E_han01() {};
    private static final E_han01 E_HAN01 = new E_han01();
    public static final E_han01 getInstance() {
        return E_HAN01;
    }
}

变种的饿汉模式

//变种饿汉模式
public class E_han02 {
    private E_han02() {};
    private static E_han02 E_HAN02 = null;
    static {
        E_HAN02 = new E_han02();
    }
    public static final E_han02 getInstance() {
        return E_HAN02;
    }
}

和上面一种饿汉模式一样，都是在类初始化即实现了自己的唯一实例。

三、枚举

它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过这是1.5后才加入的，比较生疏。

//枚举
public enum EnumTest {
    MON,TUE,WED,THU,FRI,SAT,SUN;
    /**
     * 实际上，上面这段代码是调用了7次protected Enum(String name, int ordinal);
     * new Enum<EnumTest>("MON",0);
     * ....
     * new Enum<EnumTest>("SUN",6);
     */
}

添加一个就会被影射到其构造函数中 protected Enum(String name, int ordinal)
并且没个名字都会被转换为字符串，并且顺序和你设置是的顺序一样，enum已经继承了Java.lang.Enum，不能再实现其它继承。
枚举就是一个常量(public static fianl )，有更多的方法.

懒&饿区别

实例化时间
饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。通俗一点就是：饿汉会自己提前准备好自己的实例，供使用者使用，而懒汉则是需要用时才去准备自己的实例；
线程安全性
饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，
懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是上面的3中改造getInstance()方法，这三种实现在资源加载和性能方面有些区别。