单 例 模 式

单例模式

立即加载模式(又称为 饿汉式)

public class SingleTon {
    // 1. 私有构造方法
    private SingleTon(){}
    // 不允许外界访问

    // 2. 私有静态不可变属性
    private static final SingleTon SINGLE_TON = new SingleTon();
    // 为什么使用static：保证只有一个，不加的话会导致堆内存(不断的创建对象)与栈内存(不断的执行构造防范)
    //                  不断消耗
    // 为什么使用private： 若不加private，可以通过 SingleTon.SINGLE_TON = ***,进行改写
    // 为什么使用 final ：不允许改变，再一次保证只有一份
    
    // 3. 共有静态方法
    public static SingleTon getInstance(){
        return SINGLE_TON;
    }  
    // 为什么公有：对外提供访问
    // 为什么使用static: 使其可以通过类名调用
}

缺点： 每次首先就加载，浪费一些内存

延迟加载模式（又称为 懒汉式）

public class SingleTon {

    // 1. 私有构造方法
    private SingleTon(){}


    // 2. 私有静态类
    private static SingleTon singleTon;
    // 为什么去掉final： 使用final修饰的属性 必须初始化


    // 3. 公有静态方法
    public static SingleTon getInstance(){
        if(singleTon == null){ // 设置懒加载
            singleTon = new SingleTon();
        }
        return singleTon;
    }

}

缺点： 若多个线程都进行访问，可能会出现并发问题，例如 一个线程 进入了方法 进行了判断，这时另一个线程也进入了，这就创建了两个对象

解决方法：可以在方法上用 synchronized 修饰

public synchronized static SingleTon getInstance(){
    if(singleTon == null){ // 设置懒加载
        singleTon = new SingleTon();
    }
    return singleTon;
}

但是，又出现性能问题

双重检测模式

可以理解为懒汉式的基础上 做了一些改变

​ 都是与线程安全相关

​ 不稳定的 同步的

​ 修饰属性 修饰方法

​ volatile synchrozized：用来锁住方法内部的某些程序

​ volatile：

​ 属性在某一个线程操作的时候 锁定其他线程无法获取属性

​ 属性被某一个线程修改之后， 另外线程立即可见

​ *** 可以禁止指令重新排布：

​ 创建一个对象分为两步（执行顺序不一定）：创建指针 与 分布内存

public class SingleTon {

    // 1. 私有构造方法
    private SingleTon(){}


    // 2. 私有静态类
    private  static volatile SingleTon singleTon;
    // 为什么去掉final： 使用final修饰的属性 必须初始化


    // 3. 公有静态方法
    public  static SingleTon getInstance(){
        if(singleTon == null){ //  设置懒加载 所有线程对象都进行判断
            synchronized (SingleTon.class){
                if(singleTon == null){ // 进来的线程对象非空判断
                    singleTon = new SingleTon();
                }
            }
        }
        return singleTon;
    }

}