本文主要是介绍设计模式系列(五)--单例模式详解,面试只要看这一篇文章就够了!,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!
01、概念
一、概念
1.定义:保证一个类仅有一个实例,并提供一个全局访问点。
2.类型:创建型。
3.适用场景:想确保任何情况下都绝对只有一个实例。
4.优点:a.在内存里只有一个实例,减少了内存开销;b.可以避免对资源的多重占用;c.设置全局访问点,严格控制访问。
5.重点:a.私有改造器;b.线程安全;c.延迟加载;d.序列化和反序列化安全;e.反射。
6.根据重点需要考虑的点:
1.如何防止外部调用new关键字来创建新的对象。
2.如何做到防止通过对象序列化来创建新的对象。
3.实现了cloneable的类,如何防止clone来创建新的对象。
4.如何防止反射调用构造器来创建新的对象。
5.如何做到线程安全。
二、单例模式的结构
单例模式的主要角色如下。
单例类:包含一个实例且能自行创建这个实例的类。
访问类:使用单例的类。
02、模式讲解
1.懒汉模式
这个模式,主要考虑两点:a.线程安全;b.反射破坏单列模式。
/**
*@author 繁荣Aaron
*/
public class LazySingleton {
private static LazySingleton lazySingleton = null;
private LazySingleton(){
if(lazySingleton != null){
throw new RuntimeException("单例构造器禁止反射调用");
}
}
public synchronized static LazySingleton getInstance(){
if(lazySingleton == null){
lazySingleton = new LazySingleton();
}
return lazySingleton;
}
}
首先通过私有化构造器,禁止了外部new的可能性,然后instance是static修饰的,所以在类被首次加载后,调用init 的时候,instance会被初始化,JVM保证类加载过程的线程安全,所以instance也是线程安全的。
因为在类加载初始化的时候,单例就被创建出来了,所以相对于按需延时加载,这种写法如果有大量单例需要创建,在系统刚启动时内存压力比较大。
线程安全,可以在方法上加上synchronized。
public synchronized static LazySingleton getInstance(){
if(lazySingleton == null){
lazySingleton = new LazySingleton();
}
return lazySingleton;
}
反射,可以直接抛出异常处理。
private LazySingleton(){
if(lazySingleton != null){
throw new RuntimeException("单例构造器禁止反射调用");
}
}
2.DoubleCheck双重检查模式
/**
*@author 繁荣Aaron
*/
public class LazyDoubleCheckSingleton {
private volatile static LazyDoubleCheckSingleton lazyDoubleCheckSingleton = null;
private LazyDoubleCheckSingleton(){
}
public static LazyDoubleCheckSingleton getInstance(){
if(lazyDoubleCheckSingleton == null){
synchronized (LazyDoubleCheckSingleton.class){
if(lazyDoubleCheckSingleton == null){
lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton();
//1.分配内存给这个对象
// //3.设置lazyDoubleCheckSingleton 指向刚分配的内存地址
//2.初始化对象
// intra-thread semantics
// ---------------//3.设置lazyDoubleCheckSingleton 指向刚分配的内存地址
}
}
}
return lazyDoubleCheckSingleton;
}
}
这也是很经典的单例实现,通过二次判空检查,而且只有在第一次初始化时getInstance会加锁,后面的获取都不会加锁,时间和空间效率都很高。
这里要注意的一点是instance一定要加volatile修饰符。
alloc lazyDoubleCheckSingleton (堆上分配内存)
lazyDoubleCheckSingleton init (对象初始化)
instance = lazyDoubleCheckSingleton
注意,alloc必须首先执行,但是init 和第三条 赋值语句,JVM并没有做定义,也就是说如果不加volatile,它们可以被重排序。一旦被重排序,线程B在获取instance时,有可能获取到的instance还没有执行init,这就是一次很危险的调用。但是加上volatile关键字,在jdk1.5之后,就不会再有这个问题了。
3.静态内部类模式
/**
*@author 繁荣Aaron
*/
public class StaticInnerClassSingleton {
private static class InnerClass{
private static StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton();
}
public static StaticInnerClassSingleton getInstance(){
return InnerClass.staticInnerClassSingleton;
}
private StaticInnerClassSingleton(){
if(InnerClass.staticInnerClassSingleton != null){
throw new RuntimeException("单例构造器禁止反射调用");
}
}
}
静态内部类的方式实现的单例同样是线程安全的,由JDK来保证。同时也具有延时加载的特性。这个推荐使用。
4.饿汉式模式
/**
*@author 繁荣Aaron
*/
public class HungrySingleton implements Serializable,Cloneable{
private final static HungrySingleton hungrySingleton;
static{
hungrySingleton = new HungrySingleton();
}
private HungrySingleton(){
if(hungrySingleton != null){
throw new RuntimeException("单例构造器禁止反射调用");
}
}
public static HungrySingleton getInstance(){
return hungrySingleton;
}
private Object readResolve(){
return hungrySingleton;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return getInstance();
}
}
这个模式,里面有两个方法,一个是readResolve()和clone()。第一个主要解决的是序列化的问题,第二个是解决原型设计模式的时候,拷贝的问题。
这个模式我们将在后面解决序列化和反射问题进行详细介绍。
5.Enum枚举单例
/**
*@author 繁荣Aaron
*/
public enum EnumInstance {
INSTANCE{
protected void printTest(){
System.out.println("繁荣Aaron Print Test");
}
};
protected abstract void printTest();
private Object data;
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public static EnumInstance getInstance(){
return INSTANCE;
}
}
-------------------------------
//最简单的方式
public enum EnumInstance {
INSTANCE;
}
枚举模式的构造器也是私有的,同时有个一个static final 的INSTANCE类常量,可以大胆猜测,JVM在加载枚举类时,会给所有的枚举项赋值,同时会保证过程的线程安全。
03、如何防止单例被破坏
1.解决对象序列化的问题
解决方式:
private Object readResolve(){
return hungrySingleton;
}
原理解析:
public final Object readObject()
throws IOException, ClassNotFoundException
{
if (enableOverride) {
return readObjectOverride();
}
// if nested read, passHandle contains handle of enclosing object
int outerHandle = passHandle;
try {
// TODO 从这里查看
Object obj = readObject0(false);
handles.markDependency(outerHandle, passHandle);
ClassNotFoundException ex = handles.lookupException(passHandle);
if (ex != null) {
throw ex;
}
if (depth == 0) {
vlist.doCallbacks();
}
return obj;
} finally {
passHandle = outerHandle;
if (closed && depth == 0) {
clear();
}
}
}
// ObjectInputStream#readObject0
private Object readObject0(boolean unshared) throws IOException {
...
case TC_OBJECT:
return checkResolve(readOrdinaryObject(unshared));
...
}
// ObjectInputStream#readOrdinaryObject
private Object readOrdinaryObject(boolean unshared){
...
obj = desc.isInstantiable() ? desc.newInstance() : null;
...
}
// ObjectInputStream#isInstantiable 返回 true,执行 desc.newInstance(),通过反射创建新的单例类,
// 到此时也看到了为什么在 HungrySingleton 没添加 readResolve 方法之前会返回新的对象.
/**
* Returns true if represented class is serializable/externalizable and can
* be instantiated by the serialization runtime--i.e., if it is
* externalizable and defines a public no-arg constructor, or if it is
* non-externalizable and its first non-serializable superclass defines an
* accessible no-arg constructor. Otherwise, returns false.
*/
boolean isInstantiable() {
requireInitialized();
return (cons != null);
}
// ObjectInputStream#readOrdinaryObject
private Object readOrdinaryObject(boolean unshared){
...
// 在 HungrySingleton 添加 readResolve 方法之后 desc.hasReadResolveMethod() 该方法执行为 true
if (obj != null &&
handles.lookupException(passHandle) == null &&
desc.hasReadResolveMethod())
{
// 通过反射调用 HungrySingleton 类中的 readResolve 方法返回,
// 即为我们的单例对象,所以这里讲此处返回的对象赋值给 obj,所以这里我们找到了答案
Object rep = desc.invokeReadResolve(obj);
if (unshared && rep.getClass().isArray()) {
rep = cloneArray(rep);
}
if (rep != obj) {
// Filter the replacement object
if (rep != null) {
if (rep.getClass().isArray()) {
filterCheck(rep.getClass(), Array.getLength(rep));
} else {
filterCheck(rep.getClass(), -1);
}
}
handles.setObject(passHandle, obj = rep);
}
}
return obj;
}
//
readResolveMethod = getInheritableMethod(
// 这里有 readResolve 解答了我们 HungrySingleton 类中方法命名疑惑
cl, "readResolve", null, Object.class);
2.解决反射的问题
现象:
/**
* 反射攻击解决方案及原理
* 破坏原理:通过反射暴力访问
* 解决原理:在单例类的私有化构造方法中添加防放射破坏代码,如果是通过反射调用就抛出运行时异常
*/
public class Test {
public static void main(String[] args) throws Exception {
Class objectClass = HungrySingleton.class;
Constructor constructor = objectClass.getDeclaredConstructor();
HungrySingleton instance = HungrySingleton.getInstance();
constructor.setAccessible(true);
HungrySingleton object = (HungrySingleton) constructor.newInstance();
System.out.println(instance);
System.out.println(object);
System.out.println(instance == object);
}
}
运行之后的结果:
解决方式:
private HungrySingleton(){
if(hungrySingleton != null){
throw new RuntimeException("单例构造器禁止反射调用");
}
}
注意:在私有化构造器中添加防止通过反射调用的代码(只针对在类加载初始化时就已经创建好单例对象的单例模式有效)即(饿汉式和基于内部类实现懒加载的单例模式有效,对其他懒加载无效)。
如果开发者真的使用反射来作恶,谁能拦得住呢?虽然反射最终调用的还是我们的私有构造器,在构造器里面我们可以加一些判断逻辑,但是还是不能涵盖所有的情况,因为毕竟我们的单例实现多种多样,有延时加载的,有非延时加载的。
但是通过Enum方式实现的单例是不能够被反射的,如果尝试反射Enum的构造器,会抛出一个异常,所以Enum方式实现的单例对反射安全。
3.解决clone的问题
尽量不要给单例实现cloneable接口,如果非要实现,也在重写的clone方法里,返回此单例对象。
@Override
protected Object clone() throws CloneNotSupportedException {
return getInstance();
} /**
* 通过原型模式的克隆方法破坏单例
*/
public class Test {
public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
HungrySingleton hungrySingleton = HungrySingleton.getInstance();
Method method = hungrySingleton.getClass().getDeclaredMethod("clone");
method.setAccessible(true);
HungrySingleton cloneHungrySingleton = (HungrySingleton) method.invoke(hungrySingleton);
System.out.println(hungrySingleton);
System.out.println(cloneHungrySingleton);
System.out.println(hungrySingleton == cloneHungrySingleton);
/**
* 添加相关代码,解决克隆破坏单例,再次运行
* 运行结果:
* true
*/
}
}
04
源码解读
1.spring源码中有一个AbstractFactoryBean类,该类中有一个方法getObject()方法。
@Override
public final T getObject() throws Exception {
if (isSingleton()) {
return (this.initialized ? this.singletonInstance : getEarlySingletonInstance());
}
else {
return createInstance();
}
}
2.mybatis中的ErrorContext类。
这篇关于设计模式系列(五)--单例模式详解,面试只要看这一篇文章就够了!的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!