一、单例模式
单例模式( Singleton Pattern )是指确保一个类在任何情况下都绝对只有一个实例,并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛,例如,总统,班主任等。J2EE标准中的ServletContext 、ServletContextConfig 等、Spring框架应用中的。
特点:构造方法私有,提供一个全局访问点。
实现方式:有很多,1.饿汉式 2.懒汉式 3.注册式 4.ThreadLocal
优点:内存中只有一个实例,减少内存开销;避免对资源多重占用;设置全局访问点,严格控制访问。
缺点:没有接口,扩展困难;如果要扩展单例对象,只有修改代码,没有其他途径,不符合程序的开闭原则。
![](https://i-blog.csdnimg.cn/blog_migrate/3f612596e3c882895a10a1aeb2e41f16.png)
二、饿汉式单例模式
饿汉式单例模式在类加载的时候就立即初始化,并且创建单例对象。它绝对线程安全,在线程还没出现以前就实例化了,不可能存在访问安全问题。
总结:
final:防止反射破坏单例。
饿汉式缺点:可能会造成内存空间的浪费。
饿汉式单例模式适用于单例对象较少的情况。这样写可以保证绝对线程安全、执行效率比较高。但是它的缺点也很明显,就是所有对象类加载的时候就实例化。这样一来,如果系统中有大批量的单例对象存在,那系统初始化是就会导致大量的内存浪费。
饿汉式之单例实现方式
1、标准饿汉模式
通过私有构造器,防止外部进行实例创建;通过属性在类加载时实例化对象,提供全局访问方法取得实例。利用代码的执行先后顺序,在线程还没有出现前就完成了实例化。
public class HungrySingleton {
// 静态实例代码段,饿汉实现类加载初始化时调用构造方法
private static final HungrySingleton hungrySingleton = new HungrySingleton();
// 私有方法防止外部调用创建对象
private HungrySingleton() {}
// 外部类获得单例对象方法
public static HungrySingleton getInstance() {
return hungrySingleton;
}
}
该单例实现方式可以被反序列化和反射破坏:
(1)反射破坏方式如下:该方式可以通过构造方法创建出一个全新的实例对象。
public static void reflect() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
System.out.println(Test.getInstance());
//反射破坏
//得到类
Class c = Test.class;
Constructor<?> constructor = c.getDeclaredConstructor();
//设置私有可调用
constructor.setAccessible(true);
// 打印创建的实例对象
System.out.println(constructor.newInstance());
}
![](https://i-blog.csdnimg.cn/blog_migrate/c4517bf9d9efa076399d2fc3ab3c4e94.png)
可见该方法是通过调用构造方法创建出一个新的对象。
(2)反序列化破坏单例方式如下:
public static void ser() throws IOException, ClassNotFoundException {
//反序列化
ByteArrayOutputStream outputStream=new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream=new ObjectOutputStream(outputStream);
//将类转化
objectOutputStream.writeObject(Test.getInstance());
System.out.println(Test.getInstance());
ObjectInputStream objectInputStream=new ObjectInputStream(new ByteArrayInputStream(outputStream.toByteArray()));
//读出类,变为一个新的类
Test test= (Test) objectInputStream.readObject();
System.out.println(test);
}
![](https://i-blog.csdnimg.cn/blog_migrate/970ff11134e195323b9ef17805e54b01.png)
该方式可以看出反序列化构造出的对象并不是通过构造方法。
由此针对上面两种破坏方式做出优化得到以下的代码:
public class Test implements Serializable {
//静态实例代码段,饿汉实现类加载初始化时调用构造方法
private static Test Instance=new Test();
//私有方法防止外部调用创建对象
private Test(){
if(Instance!=null)// 此处方式反射调用破环单例对象,抛出异常
throw new RuntimeException("单例模式不能创建");
System.out.println("构造方法");
}
//外部类获得单例对象方法
public static Test getInstance(){
return Instance;
}
//其他方法
public static void otherMethod(){
System.out.println("other");
}
//防止反序列化破坏单例
public Object readResolve(){
return Instance;
}
}
2、静态代码块机制
public class HungryStaticSingleton {
// 静态志方式饿汉式单例
private static final HungryStaticSingleton hungrySingleton ;
static {
hungrySingleton = new HungryStaticSingleton();
}
/**
* 私有构造
*/
private HungryStaticSingleton() {}
//取实例方法
public static HungryStaticSingleton getInstance() {
return hungrySingleton;
}
}
3、枚举类实现饿汉:枚举类实现方式不会被反射和反序列化破环单例
public enum Test_1 {
Instance;
//枚举类默认构造方法私有
Test_1(){
System.out.println("构造方法");
}
//获取对象
public static Test_1 getInstance(){
return Instance;
}
//其他方法
public static void otherMethod(){
System.out.println("other");
}
}
三、懒汉式单例模式
懒汉式类被加载的时候,没有立刻被实例化,第一次调用getInstance的时候,才真正的实例化。
如果要是代码一整场都没有调用getInstance,此时实例化的过程也就被省略掉了,又称“延时加载”
一般认为“懒汉模式” 比 “饿汉模式”效率更高。
懒汉模式有很大的可能是“实例用不到”,此时就节省了实例化的开销。
懒汉式之单例实现方式
1、普通的懒汉式
public class LazySingleton {
private LazySingleton() {
}
private volatile static LazySingleton instance;
//加入了同步代码,解决线程不安全问题
public synchronized static LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
}
这种设计明显的一个问题就是执行效率低,无论是否已经存在实例,在多线程的情况下都会发生阻塞。
对以上代码进行改进,首先让当程序中实例存在的时候,直接返回实例,不需要抢占锁。当程序中不存在实例时,再抢占锁进行创建。根据以上的思想,出现了第二种懒汉式方式:
2、双重检查锁DCL(Double Check Lock双端检锁)
public class LazyDoubleCheckSingleton {
private LazyDoubleCheckSingleton() {
}
private volatile static LazyDoubleCheckSingleton instance;
public static LazyDoubleCheckSingleton getInstance() {
//确定是否需要阻塞
if (instance == null) {
// 线程安全:双重检查锁(同步代码块)
synchronized (LazyDoubleCheckSingleton.class) {
//确定是否需要创建实例
if (instance == null) {
//这里在多线程的情况下会出现指令重排的问题,所以对共有资源instance使用关键字volatile修饰
instance = new LazyDoubleCheckSingleton();
}
}
}
return instance;
}
}
对于第二种方式,较第一种方式而言,性能提高了,但是代码的可读性差了。
DCL(Double Check Lock双端检锁)机制不一定线程安全,原因是有指令重排序的存在,加入volatile可以禁止指令重排。
原因在于某一个线程执行到第一次检测,读取到的instance不为null时,instance的引用对象可能没有完成初始化。
instance = new LazyDoubleCheckSingleton();可以分为以下3步完成(伪代码)
memory = allocate(); // 1.分配对象内存空间
instance(memory); // 2.初始化对象
instance=memory; // 3.设置instance指向刚分配的内存地址,此时instance != null
步骤2和步骤3不存在数据依赖关系,而且无论重排前还是重排后程序的执行结果在单线程中并没有改变,因此这种重排优化是允许的。
memory = allocate(); // 1.分配对象内存空间
instance=memory; // 3.设置instance指向刚分配的内存地址,此时instance != null,但是对象还没有初始化完成
instance(memory); // 2.初始化对象
但是指令重排只会保证串行语义的执行的一致性(单线程),但并不会关心多线程间的语义一致性。
所以当一条线程访问instance不为null时,由于instance实例未必已初始化完成,也就造成了线程安全问题。
3、静态内部类
/**
* 使用静态内部类,性能最优
*/
public class LazyInnerClassSingleton {
//虽然构造方法私有了,但是逃不过反射的法眼
private LazyInnerClassSingleton(){};
// 懒汉式单例
// LazyHoler里面的逻辑需等外部方法调用时候才执行
// 巧妙运用了内部类的特性
// JVM底层逻辑,完美避免了线程安全问题
public static final LazyInnerClassSingleton getInstance(){
return LazyHoler.LAZY;
}
public static class LazyHoler{
private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
}
}
为防止调用者反射破坏,可以这么写:
public class LazyInnerClassSingleton {
//虽然构造方法私有了,但是逃不过反射的法眼
private LazyInnerClassSingleton(){
// 防止调用者反射攻击;
if(LazyHoler.LAZY != null){
throw new RuntimeException("禁止创建多个实例!"); // 其他写法也可加上
}
};
// 懒汉式单例
// LazyHoler里面的逻辑需等外部方法调用时候才执行
// 巧妙运用了内部类的特性
// JVM底层逻辑,完美避免了线程安全问题
public static final LazyInnerClassSingleton getInstance(){
return LazyHoler.LAZY;
}
public static class LazyHoler{
private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
}
}
分析:静态内部类相对来说更优,LazyHoler里面的逻辑需等外部方法调用时候才执行,所以也属于懒汉式,巧妙运用了内部类的特性,JVM底层逻辑,完美避免了线程安全问题,