设计模式之单例模式
要了解单例模式,根据博主本人的学习经历,推荐先去搞懂 java中的 final和static关键字的使用,以及类加载过程。
分享两篇文章(关于 final和static)
https://www.cnblogs.com/shuaiBqi/p/11907908.html
https://blog.csdn.net/qq_41457412/article/details/80598787
1.单例模式
概念:所谓单例模式,就是采取一定的方法保证在整个的软件系统中,对某个类之只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法(静态方法)
单例模式 一个类对外只提供一个对象
将构造器私有化
提供静态的属性(本类的对象)
提供共有的静态方法
单例模式的八种方式:
1、饿汉式(静态常量)
2、饿汉式(静态代码块)
3、懒汉式(线程不安全)
4、懒汉式(线程安全,同步方法)
5、懒汉式(线程安全,同步代码块)
6、双重检查
7、静态内部类
8、枚举
1、饿汉式(静态常量)
饿汉式会造成内存的浪费,但是他是安全的没问题的,如果我们可以接受的浪费范围内,或是可以保证这个类会被用到,就是可以使用的
class Singleton{
//1. 构造器私有化,目的是不能让外面通过 new 的形式 创建Singleton 对象
private Singleton(){
}
//2. 本类内部创建实例
//final修饰的引用类型变量的地址不能改变,即始终指向一个对象
//且(被修饰的变量一定要进行初始赋值)详细代码看静态代码块!!!
private final static Singleton instance = new Singleton();
//3. 提供一个共有的静态方法 返回该实例对象
public static Singleton getInstance(){
return instance;
}
聊聊优缺点:
1、优点:代码实现简单,在类加载的时候就完成了实例化。避免了线程同步问题。
2、缺点:在类加载的时候就完成了实例化,如果我们一直没用到这个实例,就会造成内存浪费的问题。
结论:这种单例模式是可用的,但是有可能会造成内存浪费。
探讨:1)这种方式基于 classloder 机制 避免了多线程的同步问题?? 2)一般是通过调用上面代码的getInstance()方法对类进行类加载,,有没有其他方法(静态方法)可以让这个类 进行加载??
2、饿汉式(静态代码块)
直接上代码,其他跟静态常量的一样
class Singleton{
//1. 构造器私有化,目的是不能让外面通过 new 的形式 创建Singleton 对象
private Singleton(){
}
//2. 本类内部创建实例
//final修饰的引用类型变量的地址不能改变,即始终指向一个对象
private static Singleton instance;
static {
instance = new Singleton();
}
//3. 提供一个共有的静态方法 返回该实例对象
public static Singleton getInstance(){
return instance;
}
}
3、懒汉式(线程不安全)
概述:懒汉式,顾名思义就是比较懒,懒汉式不是在程序运行时就加载,而是在有人需要的时候才加载进来;
话不多说直接上代码
class SingleLazy{
//私有的构造方法
private SingleLazy(){};
private static SingleLazy instance;
//提供共有的静态方法,当使用该方法的时候才去创建对象
public static SingleLazy getInstance(){
if (instance==null){
instance = new SingleLazy();
}
return instance;
}
}
优缺点说明:
1、这种方式只是适用于单线程的情况。reason:在多线程的情况下会有这种情况发生:当一个线程进入到了if (instance==null)这行判断语句的时候,他还未来得及往下执行,另一个线程也进来判断,这时候就会产生多个实例。
2、结论:开发不可使。
4、懒汉式(线程安全,同步方法)
理念和 3 是一样的还是直接上代码
//私有的构造方法
private SingleLazy(){};
private static SingleLazy instance;
//提供共有的静态方法,当使用该方法的时候才去创建对象
public synchronized static SingleLazy getInstance(){
if (instance==null){
instance = new SingleLazy();
}
return instance;
}
优缺点说明:
1)可以看到我们的 4 相对于 3 就是在静态方法上加了 一个 synchronized 锁,他可以解决线程不安全的问题。
2)这种方式效率太低了,在大量的请求都需要这个实例(调用getInstance()方法)时,只有一个请求进来了,其他的还在方法外面排队,效率太低。
3)结论:实际开发中,不推荐使用。
思考:怎么解决这个并发问题呢??
5、懒汉式(线程安全,同步代码块)
直接上代码
//提供共有的静态方法,当使用该方法的时候才去创建对象
public static SingleLazy getInstance(){
if (instance==null){
synchronized (SingleLazy.class){
instance = new SingleLazy();
}
}
return instance;
}
直接声明这种方式在开发中是不能使用的:
because:虽然这种写法改为了 同步产生实例化的代码块,解决了 4 的效率问题,但是这种同步并不能起到线程同步的作用。在多线程访问的时候也会有多个线程同时进入if (instance==null)判断语句中,这时便产生了多个实例。
6、双重检查(双端检索机制)
推荐使用
先看代码
//私有的构造方法
private SingleLazy(){};
//volatile 作用:让这个共享的变量一旦有被修改能及时的刷新到主内存里面去。
private static volatile SingleLazy instance;
//提供共有的静态方法,当使用该方法的时候才去创建对象
public static SingleLazy getInstance(){
if (instance==null){ //判断 1️⃣
synchronized (SingleLazy.class){
if (instance==null){ // 判断 2️⃣
instance = new SingleLazy();
}
}
}
return instance;
}
1、首先这种双重检测的思想在多线程开发中经常被使用到,这不仅可以保证线程的安全性,还能提高性能。
2、原理: 当多个请求同时进入判断1️⃣后,只有一个线程会获取到同步代码块(synchronized )去创建实例,其他等待的线程在获取到锁后去判断f (instancenull) 并直接返回已创建的实例。 这样。实例化代码只用执行一次,后面再次访问时,会在if (instancenull)判断1️⃣ 的地方进行判断,,直接返回实例对象,避免反复进行同步的方法中。
3、线程安全;延迟加载;效率较高
4、结论:实际开发中,推荐使用这种单例设计模式。
7、静态内部类
推荐使用
静态内部类的特点:
1)当我们的主类进行类加载的时候我们的静态内部类是不会被加载的。这样保证了懒加载。
2)当我们调用 getInstance方法的时候它才会取这个静态内部类中的静态属性,这时候就会导致 SingletonInstance这个静态内部类被加载,,而我们 jvm 类的加载机制是线程安全的。
代码
public class StaticInnerOne {
public static void main(String[] args) {
SingletonStaticInner instance1 = SingletonStaticInner.getInstance();
SingletonStaticInner instance2 = SingletonStaticInner.getInstance();
System.out.println(instance1.hashCode());
System.out.println(instance2.hashCode());
}
}
class SingletonStaticInner{
//私有的构造方法,保证类不能被 new
private SingletonStaticInner(){};
//写一个静态内部类,该类中有一个静态属性 SingletonStaticInner
private static class SingletonInstance{
private static final SingletonStaticInner INSTANCE = new SingletonStaticInner();
}
// 提供一个静态的方法,再被就调用的时候直接返回 SingletonInstance.INSTANCE 实例
public static SingletonStaticInner getInstance(){
return SingletonInstance.INSTANCE;
}
}
静态内部类的单例模式原理主要是两点:(再次强调)
1)静态内部类方式在SingletonStaticInner类被加载的时候并不会立即实例化,而是在调用 getInstance() 方法的时候才会加载 SingletonInstance 这个类,从而实现懒加载的原理。
2)类的静态属性只会在第一次加载类的时候初始化,所以在这里,JVM帮助我们保证了线程的安全性,在类进行初始化的时候,别的线程是无法进入的。
3)实际开发中也是推荐使用的。
注:为什么用 final修饰静态变量
***局部内部类在访问他所在方法中的局部变量用final修饰的好处:
因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
8、枚举
推荐使用
public class EnumOne {
public static void main(String[] args) {
SingletonOne instance1 = SingletonOne.INSTANCE;
SingletonOne instance2 = SingletonOne.INSTANCE;
System.out.println(instance1 == SingletonOne.INSTANCE);
System.out.println(instance1.hashCode());
System.out.println(instance2.hashCode());
instance1.sayHello();
}
}
enum SingletonOne {
INSTANCE; //属性
public void sayHello(){
System.out.println("ok~");
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2oa36cMc-1606022431193)(C:\Users\DELL\AppData\Roaming\Typora\typora-user-images\image-20201122122928208.png)]
优缺点介绍:
1)用枚举来实现单例模式。不仅能避免多线程同步的问题,而且还能防止反序列化重新创建新的对象。
2)这种方式是 java 作者 Josh Bloch提倡的方式
原理:
1️⃣:枚举类的构造器是private私有的,保障了内存中只有枚举的一个实例。
2️⃣:枚举类的实例会在类加载的时候线程安全的进行初始实例化,在类加载的时候,JVM会对()方法加锁,其他线程都需要阻塞等待,直到活动线程执行()方法完毕。需要注意的是,其他线程虽然会被阻塞,但如果执行()方法的那条线程退出()方法后,其他线程唤醒后不会再次进入()方法。同一个类加载器下,一个类型只会初始化一次。
9、单例模式源码举例
1)JDK的 java lang 包下的Runtime类 使用的就是饿汉式单例模式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6OhjS5Y3-1606022431195)(C:\Users\DELL\AppData\Roaming\Typora\typora-user-images\image-20201122130447736.png)]
单例模式总结:
1)单例模式保证了,系统内存中只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统的性能
2)当想实例化一个单例类的时候,必须要记住使用响应的获取对象的方法,而不是使用 new
3)单例模式使用的场景:需要频繁的进行创建和销毁的对象,创建对象时耗时过多或耗费资源过多(即:重量级对象),但又经常用到的对象、工具类对象、频繁访问数据库文件对象(比如数据源、session工厂等)
9、单例模式源码举例
1)JDK的 java lang 包下的Runtime类 使用的就是饿汉式单例模式
[外链图片转存中…(img-6OhjS5Y3-1606022431195)]
单例模式总结:
1)单例模式保证了,系统内存中只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统的性能
2)当想实例化一个单例类的时候,必须要记住使用响应的获取对象的方法,而不是使用 new
3)单例模式使用的场景:需要频繁的进行创建和销毁的对象,创建对象时耗时过多或耗费资源过多(即:重量级对象),但又经常用到的对象、工具类对象、频繁访问数据库文件对象(比如数据源、session工厂等)