五种单例模式
在整个程序中,保持只有一个实例对象,就是单例模式。
单例模式可以减少构建,GC的次数,提升性能,还能减少堆内存的开销。
1. 懒汉式
-
在需要使用对象的时候,才进行创建
-
通过private构造方法,确保外部不能new出对象,通过一个静态方法进行对象获取。
public class LazySingleton implements Serializable {
private static LazySingleton lazySingleton = null;
private LazySingleton() {
}
public static LazySingleton getInstance(){
if(lazySingleton == null){
lazySingleton = new LazySingleton();
}
return lazySingleton;
}
}
需要注意的是,懒汉式是线程不安全的,并发情况下有线程安全问题,需要进行同步处理。
可以在getInstance()方法上加上synchronized。但是锁的粒度很大,所以引出了双重检查锁
2. 双重检查锁
- 通过两个if判断,加上同步锁进行实现
- 只进行一次判断上锁的话,上锁解锁后,单例对象就被重置了,因为有可能多个线程同时都通过了第一次判断,只是没抢到锁
- 而且,需要加上volatile保证可见性和同步性,因为锁住的是class对象,不是单例对象,所以JMM保证的unlock刷到主存,lock读到工作内存只对class对象起作用,单例对象的可见性无法保证,同样的,是class对象的unlock操作在lock操作之前,happens before原则也无法保证有序性,因为整个临界区内根本找不到一个和class对象相关的操作。
public class DoubleCheckSingleton {
private static volatile DoubleCheckSingleton doubleCheckSingleton ;
private DoubleCheckSingleton(){
}
public static DoubleCheckSingleton getInstance(){
if(doubleCheckSingleton ==null){
synchronized (DoubleCheckSingleton.class){
if (doubleCheckSingleton == null){
doubleCheckSingleton = new DoubleCheckSingleton();
}
}
}
return doubleCheckSingleton;
}
}
3. 静态内部类
双重检查锁对于同步控制特别的复杂繁琐,有没有什么底层已经进行了的同步操作可以利用的呢?
答案是类加载的loadclass是被synchronized修饰的,类的加载是同步的,类加载进行到初始化部分的时候会对静态变量赋初始值,也会执行静态代码块。
-
在单例类中,通过私有的静态内部类,创建单例对象
-
静态内部类只有在被调用的时候才会被加载,实现了懒加载。
public class StaticInnerClassSingleton {
/**
* 第一次被调用到的时候才会进行类加载,进行初始化(JVM相关知识,加载、连接(验证,准备,解析)、初始化(为静态变量赋值)
*/
private static class InnerClass{
private static final StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton();
}
private StaticInnerClassSingleton(){
System.out.println("StaticInnerClassSingleton初始化......");
}
public static StaticInnerClassSingleton getInstance(){
return InnerClass.staticInnerClassSingleton;
}
}
4. 饿汉式
如果不追求懒加载,那么还是使用类加载的同步控制的话,直接在单例类放一个静态变量,或者在静态代码块进行初始化。
public class HungrySingleton {
private static final HungrySingleton hungrySingleton ;
static {
hungrySingleton = new HungrySingleton();
}
private HungrySingleton(){
System.out.println("HungrySingleton初始化.....");
}
public static HungrySingleton getInstance(){
return hungrySingleton;
}
}
5. 枚举
前面一步一步的推导出到了饿汉式,看着很完美了,但是单例模式会被反射破坏。通过反射获取到构造函数后,可以强制开启权限执行。序列化和反序列化也都是基于反射创建对象的。
那么什么单例模式不会有这样的情况呢?
枚举。枚举是最佳的单例模式实现方式。
枚举在底层的构造函数是强制private的,反射无法打开权限,枚举对象的反序列化是通过name在堆内找到对应的对象
public enum EnumSingleton implements Serializable {
EnumSingleton("枚举单例");
private String name;
EnumSingleton() {
}
EnumSingleton(String name) {
this.name = name;
}
public void doSomething(String something) {
System.out.println(name + ":" + something);
}
}
原文地址:https://blog.csdn.net/qq_53711959/article/details/135833969
免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!