一、什么是单例模式
- 单例模式就是单例对象的类只能允许一个实例存在
- 通过单例模式可以保证系统中,应⽤该模式的类只有⼀ 个对象实例
二、使⽤场景
- 业务系统全局只需要⼀个对象实例,⽐如发号器、 redis连接对象等
- Spring IOC容器中的bean默认就是单例
- spring boot 中的controller、service、dao层中通过 @autowire的依赖注⼊对象默认都是单例的
- 需要频繁实例化然后销毁的对象
- 创建对象时耗时过多或者耗资源过多,但又经常用到的对象
三、单例模式的实现
饿汉式单例(程序加载时就创建)
/**
* 饿汉单例模式
* 直接new对象,私有构造函数,对外暴露获取方法放回对象实例
*/
public class SingletonHunger {
private static SingletonHunger singletonHunger = new SingletonHunger();
private SingletonHunger(){}
public static SingletonHunger getInstance(){
return singletonHunger;
}
}
懒汉式单例(程序加载时不创建,需要时才进行创建)
/**
* 懒汉式单例模式
* 私有化构造函数,声明对象,对外暴露获取实例方法,在方法中创建对象
*/
public class SingletonLazy {
// private static SingletonLazy instance;
/**
* 构造函数私有化
*/
private SingletonLazy(){
System.out.println("实例被创建");
}
/**
* 单例对象的方法
*/
public void process(){
System.out.println("方法调用成功");
}
/**
* 第一种方式
* 对外暴露一个方法获取类的对象
*
* 线程不安全,多线程下存在安全问题
*
*/
// public static SingletonLazy getInstance(){
// if(instance == null){
// instance = new SingletonLazy();
// }
// return instance;
// }
/**
* 第二种实现方式
* 通过加锁 synchronized 保证单例
*
* 采用synchronized 对方法加锁有很大的性能开销
*
* 解决办法:锁粒度不要这么大
*
* @return
*/
// public static synchronized SingletonLazy getInstance(){
// if(instance == null){
// instance = new SingletonLazy();
// }
// return instance;
// }
/**
* 第三种实现方式
*
* DCL 双重检查锁定 (Double-Checked-Locking),在多线程情况下保持高性能
*
* 这是否安全,instance = new SingletonLazy(); 并不是原子性操作
* 1、分配空间给对象
* 2、在空间内创建对象
* 3、将对象赋值给引用instance
*
* 假如线程 1-》3-》2顺序,会把值写会主内存,其他线程就会读取到instance最新的值,但是这个是不完全的对象
* (指令重排)
* @return
*/
// public static SingletonLazy getInstance(){
// if(instance == null){
// // A、B
// synchronized (SingletonLazy.class){
// if(instance == null) {
// instance = new SingletonLazy();
// }
// }
// }
// return instance;
// }
/**
* volatile是Java提供的关键字,它具有可见性和有序性,
*
* 指令重排序是JVM对语句执行的优化,只要语句间没有依赖,那JVM就有权对语句进行优化
*
* 禁止了指令重排
*/
private static volatile SingletonLazy instance;
public static SingletonLazy getInstance() {
//第一重检查
if (instance == null) {
// A、B ,锁定
synchronized (SingletonLazy.class) {
//第二重检查
if (instance == null) {
instance = new SingletonLazy();
}
}
}
return instance;
}
}
public class Main {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()-> System.out.println(SingletonLazy.getInstance())).start();
}
}
}
四、区别跟优缺点
- 饿汉:直接创建对象
- 优点:实现简单没有多线程同步问题
- 缺点:不管用不用,对象始终占内存
- 懒汉:按需创建对象
- 优点:资源利用率高
- 缺点:第一次加载时不够快,多线程使用不必要的同步开销大
五、单例模式中饿汉跟懒汉的选择
- 如果对象不⼤,且创建不复杂,直接⽤饿汉的⽅式即可
- 其他情况则采⽤懒汉实现⽅式
注释:仅代表自己学习观点以作笔记,如有瑕疵望谅解