带着问题思考:
- 单例模式存在的意义?
- 单例模式的几种写法?
- 单例模式在实战中的使用如何?
- 如何应对面试官?
为什么要用单例模式
单例模式要写都很简单,都知道最终就是返回一个单实例的对象.
那么为什么要那么折腾?因为这样可以确保 java 内存中只有一个这个类的实例,减少了内存开支。
可能大家觉得这才多少内存? 试想一下,1000 个对象,在同一个程序里面有大量的线程同时使用且 GC 没有及时回收,这会造成多大的资源占用。
Java对象的大小
基本数据的类型的大小是固定的,这里就不多说了。对于非基本类型的Java对象,其大小就值得商榷。
在Java中,一个空Object对象的大小是8byte,这个大小只是保存堆中一个没有任何属性的对象的大小。
看下面语句:
Object ob = new Object();
这样在程序中完成了一个Java对象的生命,但是它所占的空间为:4byte+8byte。4byte是Java栈中保存引用的所需要的空间。
而那8byte则是Java堆中对象的信息。因为所有的Java非基本类型的对象都
需要默认继承Object对象,因此不论什么样的Java对象,其大小都必须是大于8byte。
有了Object对象的大小,我们就可以计算其他对象的大小了。
Class NewObject {
int count;
boolean flag;
}
其大小为:空对象大小(8byte)+int大小(4byte)+Boolean大小(1byte)+空Object引用的大小(4byte)=17byte。按照最小8byte的计算=24 byte。
这还只是基本类型的对象,封装类型的最少16byte,也就是基本翻倍。在实际项目中,我们一个对象的大小一般都是超过 1024 byte。
单例模式的几种写法
- 饿汉模式
- 懒汉模式
- 枚举模式
- 内部类模式
饿汉模式
特点:
- 私有的构造器
- 私有静态的对象本身属性,且初始化 new 对象本身
- 公有的获取对象的方法
- 优点:从它的实现中我们可以看到,这种方式的实现比较简单,在类加载的时候就完成了实例化,避免了线程的同步问题。
- 缺点:由于在类加载的时候就实例化了,所以没有达到Lazy Loading(懒加载)的效果,也就是说可能我没有用到这个实例,但是它
也会加载,会造成内存的浪费(但是这个浪费可以忽略,所以这种方式也是推荐使用的)。
public class SingletonEHan {
private SingletonEHan() {}
/**
* 单例模式的饿汉式[可用]
*/
private static SingletonEHan singletonEHan = new SingletonEHan();
public static SingletonEHan getInstance() {
return singletonEHan;
}
}
懒汉模式(线程不安全模式),不推荐使用
- 缺点:线程不同步,可能会产生多个实例,因此不推荐使用,这里贴上代码主要用来比较写法。
public class SingletonLanHan {
private SingletonLanHan() { }
/**
* 单例模式的懒汉式[线程不安全,不可用]
*/
private static SingletonLanHan singletonLanHan;
public static SingletonLanHan getInstance() {
if (singletonLanHan == null) { // 这里线程是不安全的,可能得到两个不同的实例
singletonLanHan = new SingletonLanHan();
}
return singletonLanHan;
}
}
懒汉模式(线程安全,但是效率不高)
- 优点:延迟加载,需要使用的时候才实例化,不会浪费性能,但其实浪费也是微乎其微。线程安全,保证只有一个实例。
- 缺点:每次使用 getSingletonLanHanTwo 方法的时候都会加锁。
其实这个方法里面只要求第一次实例化对象的时候加锁,然后返回对象,没有必要在每次请求的时候都加锁。这样我们还可以继续优化代码,做到双重验证+实例化时加锁。
public class SingletonLanHan {
private SingletonLanHan() { }
/**
* 4. 懒汉式线程安全的:[线程安全,效率低不推荐使用]
* <p>
* 缺点:效率太低了,每个线程在想获得类的实例时候,执行getInstance()方法都要进行同步。
* 而其实这个方法只执行一次实例化代码就够了,
* 后面的想获得该类实例,直接return就行了。方法进行同步效率太低要改进。
*/
private static SingletonLanHan singletonLanHanTwo;
public static synchronized SingletonLanHan getSingletonLanHanTwo() {
if (singletonLanHanTwo == null) { // 这里线程是不安全的,可能得到两个不同的实例
singletonLanHanTwo = new SingletonLanHan();
}
return singletonLanHanTwo;
}
}
懒汉模式(双重验证+锁)
特点:
- 私有的构造器
- 私有静态的对象本身属性
- 公有的获取对象的方法
-
优点:延迟加载,需要使用的时候才实例化,不会浪费性能,但其实浪费也是微乎其微。线程安全,双重验证机制,可以保证线程同步且只会实例一个对象;
public class SingletonLanHan { private SingletonLanHan() { } /** * 单例模式懒汉式双重校验锁[推荐用] * 懒汉式变种,属于懒汉式的最好写法,保证了:延迟加载和线程安全 */ private static SingletonLanHan singletonLanHanFour; public static SingletonLanHan getSingletonLanHanFour() { if (singletonLanHanFour == null) { synchronized (SingletonLanHan.class) { if (singletonLanHanFour == null) { singletonLanHanFour = new SingletonLanHan(); } } } return singletonLanHanFour; } }
枚举模式
懒汉模式、饿汉模式 真的万无一失吗?不见得。
- 私有化构造器并不保险
“享有特权的客户端可以借助AccessibleObject.setAccessible方法,通过反射机制调用私有构造器。如果需要低于这种攻击,可以修改构造器,让它在被要求创建第二个实例的时候抛出异常。
- 序列化问题
任何一个readObject方法,不管是显式的还是默认的,它都会返回一个新建的实例,这个新建的实例不同于该类初始化时创建的实例。”当然,这个问题也是可以解决的,想详细了解的同学可以翻看《effective java》第77条:对于实例控制,枚举类型优于readResolve
枚举模式:
- 优点:避免同步问题;防止反序列化重新创建对象。
/**
* Created by holy
* 枚举 [极推荐使用]
*
* 这里SingletonEnum.INSTANCE
* 这里的INSTANCE 即为 SingletonEnum 类型的引用所以得到它就可以调用枚举中的方法了。
* 借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象
*/
public enum SingletonEnum {
INSTANCE;
private SingletonEnum() {
}
public void whateverMethod() {
}
}
上面的代码在编译后,会编译成
public final class SingletonEnum extends java.lang.Enum<SingletonEnum> {
public static final SingletonEnum instance;
public static SingletonEnum[] values();
public static SingletonEnum valueOf(java.lang.String);
public void whateverMethod();
static {}
}
Java规范中规定,每个枚举类型及其定义的枚举变量在JVM中都是唯一的.
因此在枚举类型的序列化和反序列化上,
Java做了特殊的规定。在序列化的时候Java仅仅是将枚举对象的name属性输到结果中,反序列化的时候则是通过
java.lang.Enum的valueOf()方法来根据名字查找枚举对象。也就是说,序列化的时候只将属性名称输出,
反序列化的时候再通过这个名称,查找对应的枚举类型,因此反序列化后的实例也会和之前被序列化的对象实例相同。
内部类模式(推荐)
这种方式跟饿汉式方式采用的机制类似,但又有不同。
两者都是采用了类装载的机制来保证初始化实例时只有一个线程。
不同的地方:
在饿汉式方式是只要Singleton类被装载就会实例化,
内部类是在需要实例化时,调用getInstance方法,才会装载SingletonHolder类
- 优点:避免了线程不安全,延迟加载,效率高。
public class SingletonIn {
private SingletonIn() {
}
private static class SingletonInHodler {
private static SingletonIn singletonIn = new SingletonIn();
}
public static SingletonIn getSingletonIn() {
return SingletonInHodler.singletonIn;
}
}
spring 中获取单例源码,采用的哪种方式?在面试中如何应对?
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
Map var4 = this.singletonObjects;
synchronized(this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
从源码分析来看,采用的就是双重验证+锁机制。现在为止,我们接触了单例的几种写法,也明白了其中的优点和缺点,在spring 中的源码我们也看了,
在面对面试官的提问的时候,就可以尽情聊(chui)天(niu)了。
我也面试过很多人,其实作为一个面试官,在单例这个问题上,只要回答到他们一些优缺点就感觉很不错了,因为说明真正理解了这种模式且对 JVM
有一定的理解,如果能够详细的做出详细比较并说出自己的理解,就算非常优秀了。
程序领域(id:think-holy)
作者:holy