一句话设计模式1: 单例模式

单例模式:全局唯一的对象。

文章目录

• 单例模式:全局唯一的对象。
• 前言
• 一、为什么要全局唯一？
• 二、如何实现单例

• 1. 注入到spring中
• 2. 饿汉式
• 3. 懒汉式

• 第一种: 静态内部类
• 第二种: synchronized 关键字
• 第二种: 双重锁检查

• 总结

前言

单例可以说是设计模式中很常用的模式了,但也可以说是很复杂的模式;

一、为什么要全局唯一？

1 减少由于不断创建对象造成的开销以及资源的浪费
2 一些场景中单例模式可以保证数据一直性: 例如数据连接池等

二、如何实现单例

1. 注入到spring中

由于java目前99%的项目都是在spring提供的强大生态中编码的,所以可以利用spring的注解实现单例,例如: @Bean @Service @Controller … 几乎常见的注解都是让对象变为单例

2. 饿汉式

所谓饿汉式就是: 提前将对象创建好;对应的还有懒汉式: 什么时候用这个对象,再去创建,不用一直不创建;
这种的代码很多,我随便粘贴,大家看下

public class Singleton {
    private static Singleton singleton=new Singleton();  //内部创建实例
    private Integer data=0;  //成员变量
    private Singleton(){}   //构造函数私有化
    //本身线程安全
    public static  Singleton getTarget(){
        return singleton;
    } 
}

1 构造函数必须私有化,否则其他人可以new 这个对象就不是单例了
2 线程安全,就是在多线程情况下,也是可以用这种方式的
3 可以看到是利用static 相当于预先创建好了对象并加载完成了,所以 说多线程情况下也是安全的

3. 懒汉式

不提前创建,用到了才回去创建对象;

第一种: 静态内部类

public class Singleton { 
    private Integer data=0;  //成员变量
    private Singleton(){}   //构造函数私有化
    //静态内部类
    private static class Target{
        private static final Singleton singleton = new Singleton();//内部类创建实例
    }
    //当任何一个线程第一次调用getTarget()时，都会使Target被
    //加载和被初始化，此时静态初始化器将执行Singleton的初始化操作。
    // (被调用时才进行初始化！)初始化静态数据时，Java提供了的线程安全性保证。
    public static final Singleton getTarget(){
        return Target.singleton;
    }
}

此种方式,相当于在Singleton 中加入了一个属性,这个属性是一个静态内部类,与之前的类似;
线程安全的原因是: 一个类在初始化的时候,jvm会获取一个锁,保证同步多个线程对同一个类的初始化; 它没有防止一个线程中的的对于类初始化的 “三步” 的指令重排,但是防止了其他线程可以看到这个指令重排的结果;

第二种: synchronized 关键字

public class LazySingleton {
    private LazySingleton() {
    }

    private volatile static LazySingleton instance;

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

1 构造函数必须私有化
2 volatile 可以保证多线程下该变量能实时被其他线程感知到
3 synchronized 可以保证单线程下的并发访问,所以二者相结合,保证了这种写法的多线程模式下的安全

但是此种方式性能不高,因为synchronized 会让多个线程阻塞;

第二种: 双重锁检查

public class LazyDoubleCheckSingleton {
    private LazyDoubleCheckSingleton() {
    }

    private volatile static LazyDoubleCheckSingleton instance;

    public static LazyDoubleCheckSingleton getInstance() {
        //确定是否需要阻塞
        if (instance == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
                //确定是否需要创建实例
                if (instance == null) {
                    //这里在多线程的情况下会出现指令重排的问题，所以对共有资源instance使用关键字volatile修饰
                    // 由于此段代码为赋值操作,与i++类似,非原子操作 分为三步 abc
                    //a. memory = allocate() //分配内存
					//b. ctorInstanc(memory) //初始化对象
					//c. instance = memory   //设置instance指向刚分配的地址
					// 正常顺序为 abc 指令重排可能为 acb,这样多线程的情况下,可能会返回一个 执行了ac 但是为执行b,未初始化的一个对象
                    instance = new LazyDoubleCheckSingleton();
                }
            }
        }
        return instance;
    }

}

1 构造函数必须私有化
2 synchronized (LazyDoubleCheckSingleton.class) 注意这里是 类锁 ,由于是类锁,所以可以保证多线程下的安全(类锁和对象锁 感兴趣的可以自行查看)
3 多线程情况下,同时到达第一个判断的线程可能会很多,但是同时到达第二个判断的应该只有一个,所以当第二个判断首次进入后,就会创建这个对象,并重新刷会主内存(volatile),然后其他线程再次到达 第二个判断的时候,就都知道这个判断结果不为null ,所以就会返回已经创建好的对象了
4 利用防止初始化类的时候的 “三步” 指令重排序解决

总结

单例模式其实就是通过一种手段实现一个对象的全局唯一实例, 文中所示,主要有两种思路,一种是提前创建,一种是懒加载访问的时候创建; 提前创建通过static 等可以时间,相对简单,对于懒加载方式,则需要通过

synchronized 和 volatile 等关键字实现为主;