设计模式-单例模式
定义
单例模式 : 确保一个类在任何情况下都绝对只有一个实例,并提供一个全局访问点。
应用场景
J2EE标准中,ServletContext\ServletContextConfig等。
spring中的AppliationContext
数据库的连接池
。。。。
实现方式
(1)饿汉式
特点:在类加载的时候就立即创建单例对象。绝对线程安全,因为在线程还未出现前就实例化了,不可能出现访问安全问题。
优点:没有加任何的锁,执行效率高,用户体验好
缺点:类加载的时候就初始化,不管是否使用到都占着空间,可能会造成内存浪费
例子:spring IOC容器ApplicationContext就是典型的饿汉式单例。
方式一:
public class HungrySingleton { //先静态、后动态 //先属性、后方法 //先上后下 private static final HungrySingleton hungrySingleton = new HungrySingleton(); private HungrySingleton(){} public static HungrySingleton getInstance(){ return hungrySingleton; } }
方式二:
//饿汉式静态块单例 public class HungryStaticSingleton { private static final HungryStaticSingleton hungrySingleton; static { hungrySingleton = new HungryStaticSingleton(); } private HungryStaticSingleton(){} public static HungryStaticSingleton getInstance(){ return hungrySingleton; } }
(2)懒汉式
特点:被外部调用的时候才会实例化
//懒汉式单例 //在外部需要使用的时候才进行实例化 public class LazySimpleSingleton { private LazySimpleSingleton(){} //静态块,公共内存区域 private static LazySimpleSingleton lazy = null; public static LazySimpleSingleton getInstance(){ if(lazy == null){ lazy = new LazySimpleSingleton(); } return lazy; } }
public class ExectorThread implements Runnable{ @Override public void run() { LazySimpleSingleton singleton = LazySimpleSingleton.getInstance(); System.out.println(Thread.currentThread().getName() + ":" + singleton); } }
public class LazySimpleSingletonTest { public static void main(String[] args) { Thread t1 = new Thread(new ExectorThread()); Thread t2 = new Thread(new ExectorThread()); t1.start(); t2.start(); System.out.println("End"); } }
运行结果:
通过不断切换线程,并观测其内存状态,我们发现在线程环境下LazySimpleSingleton
被实例化了两次。有时,我们得到的运行结果可能是相同的两个对象,实际上是被后面
执行的线程覆盖了,我们看到了一个假象,线程安全隐患依旧存在。那么,我们如何来
优化代码,使得懒汉式单例在线程环境下安全呢?来看下面的代码,给getInstance()加
上synchronized 关键字,是这个方法变成线程同步方法:
public class LazySimpleSingleton { private LazySimpleSingleton(){} //静态块,公共内存区域 private static LazySimpleSingleton lazy = null; public synchronized static LazySimpleSingleton getInstance(){ if(lazy == null){ lazy = new LazySimpleSingleton(); } return lazy; } }
这时候,我们再来调试。当我们将其中一个线程执行并调用getInstance()方法时,另一
个线程在调用getInstance()方法,线程的状态由RUNNING 变成了MONITOR,出现阻
塞。直到第一个线程执行完,第二个线程才恢复RUNNING 状态继续调用getInstance()
方法。
线程安全的问题便解决了。但是,用synchronized 加锁,在线程数量比较多情况下,如果CPU 分配压力上升,会导致大批
量线程出现阻塞,从而导致程序运行性能大幅下降。那么,有没有一种更好的方式,既兼顾线程安全又提升程序性能呢?答案是肯定的。我们来看双重检查锁的单例模式:
public class LazyDoubleCheckSingleton { private volatile static LazyDoubleCheckSingleton lazy = null; private LazyDoubleCheckSingleton(){} public static LazyDoubleCheckSingleton getInstance(){ if(lazy == null){ synchronized (LazyDoubleCheckSingleton.class){ if(lazy == null){ lazy = new LazyDoubleCheckSingleton(); //1.分配内存给这个对象 //2.初始化对象 //3.设置lazy 指向刚分配的内存地址 } } } return lazy; } }
但是,用到synchronized 关键字,总归是要上锁,对程序性能还是存在一定影响的。难
道就真的没有更好的方案吗?当然是有的。我们可以从类初始化角度来考虑,看下面的
代码,采用静态内部类的方式:
//这种形式兼顾饿汉式的内存浪费,也兼顾synchronized 性能问题 //完美地屏蔽了这两个缺点 public class LazyInnerClassSingleton { //默认使用LazyInnerClassGeneral 的时候,会先初始化内部类 //如果没使用的话,内部类是不加载的 private LazyInnerClassSingleton(){} //每一个关键字都不是多余的 //static 是为了使单例的空间共享 //保证这个方法不会被重写 public static final LazyInnerClassSingleton getInstance(){ //在返回结果以前,一定会先加载内部类 return LazyHolder.LAZY; } //默认不加载 private static class LazyHolder{ private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton(); } }
反射破坏单例
大家有没有发现,上面介绍的单例模式的构造方法除了加上private 以外,没有做任何处
理。如果我们使用反射来调用其构造方法,然后,再调用getInstance()方法,应该就会
两个不同的
实例。现在来看一段测试代码,以LazyInnerClassSingleton 为例:
public class LazyInnerClassSingletonTest { public static void main(String[] args) { try{ //很无聊的情况下,进行破坏 Class<?> clazz = LazyInnerClassSingleton.class; //通过反射拿到私有的构造方法 Constructor c = clazz.getDeclaredConstructor(null); //强制访问,强吻,不愿意也要吻 c.setAccessible(true); //暴力初始化 Object o1 = c.newInstance(); //调用了两次构造方法,相当于new 了两次 //犯了原则性问题, Object o2 = c.newInstance(); System.out.println(o1 == o2); // Object o2 = c.newInstance(); }catch (Exception e){ e.printStackTrace(); } } }
显然,是创建了两个不同的实例。现在,我们在其构造方法中做一些限制,一旦出现多
次重复创建,则直接抛出异常。来看优化后的代码:
//史上最牛B 的单例模式的实现方式 public class LazyInnerClassSingleton { //默认使用LazyInnerClassGeneral 的时候,会先初始化内部类 //如果没使用的话,内部类是不加载的 private LazyInnerClassSingleton(){ if(LazyHolder.LAZY != null){ throw new RuntimeException("不允许创建多个实例"); } } //每一个关键字都不是多余的 //static 是为了使单例的空间共享 //保证这个方法不会被重写,重载 public static final LazyInnerClassSingleton getInstance(){ //在返回结果以前,一定会先加载内部类 return LazyHolder.LAZY; } //默认不加载 private static class LazyHolder{ private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton(); }
序列化破坏单例
当我们将一个单例对象创建好,有时候需要将对象序列化然后写入到磁盘,下次使用时
再从磁盘中读取到对象,反序列化转化为内存对象。反序列化后的对象会重新分配内存,
即重新创建。那如果序列化的目标的对象为单例对象,就违背了单例模式的初衷,相当
于破坏了单例,来看一段代码:
//反序列化时导致单例破坏 public class SeriableSingleton implements Serializable { //序列化就是说把内存中的状态通过转换成字节码的形式 //从而转换一个IO 流,写入到其他地方(可以是磁盘、网络IO) //内存中状态给永久保存下来了 //反序列化 //讲已经持久化的字节码内容,转换为IO 流 //通过IO 流的读取,进而将读取的内容转换为Java 对象 //在转换过程中会重新创建对象new public final static SeriableSingleton INSTANCE = new SeriableSingleton(); private SeriableSingleton(){} public static SeriableSingleton getInstance(){ return INSTANCE; } }
public class SeriableSingletonTest { public static void main(String[] args) { SeriableSingleton s1 = null; SeriableSingleton s2 = SeriableSingleton.getInstance(); FileOutputStream fos = null; try { fos = new FileOutputStream("SeriableSingleton.obj"); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(s2); oos.flush(); oos.close(); FileInputStream fis = new FileInputStream("SeriableSingleton.obj"); ObjectInputStream ois = new ObjectInputStream(fis); s1 = (SeriableSingleton)ois.readObject(); ois.close(); System.out.println(s1); System.out.println(s2); System.out.println(s1 == s2); //false } catch (Exception e) { e.printStackTrace(); } } }
运行结果中,可以看出,反序列化后的对象和手动创建的对象是不一致的,实例化了两
次,违背了单例的设计初衷。那么,我们如何保证序列化的情况下也能够实现单例?其
实很简单,只需要增加readResolve()方法即可。来看优化代码:
package com.gupaoedu.vip.pattern.singleton.seriable; import java.io.Serializable; public class SeriableSingleton implements Serializable { public final static SeriableSingleton INSTANCE = new SeriableSingleton(); private SeriableSingleton(){} public static SeriableSingleton getInstance(){ return INSTANCE; } private Object readResolve(){ return INSTANCE; } }
虽然,增加readResolve()方法返回实例,解决了单
例被破坏的问题。但是,我们通过分析源码以及调试,我们可以看到实际上实例化了两
次,只不过新创建的对象没有被返回而已。那如果,创建对象的动作发生频率增大,就
意味着内存分配开销也就随之增大,难道真的就没办法从根本上解决问题吗?下面我们
来注册式单例也许能帮助到你。
注册式单例
注册式单例又称为登记式单例,就是将每一个实例都登记到某一个地方,使用唯一的标
识获取实例。注册式单例有两种写法:一种为容器缓存,一种为枚举登记。先来看枚举
式单例的写法,来看代码,创建EnumSingleton 类:
public enum EnumSingleton { INSTANCE; private Object data; public Object getData() { return data; } public void setData(Object data) { this.data = data; } public static EnumSingleton getInstance(){ return INSTANCE; } }
public class EnumSingletonTest { public static void main(String[] args) { try { EnumSingleton instance1 = null; EnumSingleton instance2 = EnumSingleton.getInstance(); instance2.setData(new Object()); FileOutputStream fos = new FileOutputStream("EnumSingleton.obj"); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(instance2); oos.flush(); oos.close(); FileInputStream fis = new FileInputStream("EnumSingleton.obj"); ObjectInputStream ois = new ObjectInputStream(fis); instance1 = (EnumSingleton) ois.readObject(); ois.close(); System.out.println(instance1.getData()); System.out.println(instance2.getData()); System.out.println(instance1.getData() == instance2.getData()); //true }catch (Exception e){ e.printStackTrace(); } } }
那么反射是否能破坏枚举式单例呢?来看一段测试代码:
public static void main(String[] args) { try { Class clazz = EnumSingleton.class; Constructor c = clazz.getDeclaredConstructor(); c.newInstance(); }catch (Exception e){ e.printStackTrace(); } }
报的是java.lang.NoSuchMethodException 异常,意思是没找到无参的构造方法。这 时候,我们打开java.lang.Enum 的源码代码,查看它的构造方法,只有一个protected 的构造方法,代码如下:
protected Enum(String name, int ordinal) { this.name = name; this.ordinal = ordinal; }
那我们再来做一个这样的测试:
public static void main(String[] args) { try { Class clazz = EnumSingleton.class; Constructor c = clazz.getDeclaredConstructor(String.class,int.class); c.setAccessible(true); EnumSingleton enumSingleton = (EnumSingleton)c.newInstance("Tom",666); }catch (Exception e){ e.printStackTrace(); } }
这时错误已经非常明显了,告诉我们Cannot reflectively create enum objects,不能
用反射来创建枚举类型。
接下来看注册式单例还有另一种写法,容器缓存的写法,创建ContainerSingleton 类:
public class ContainerSingleton { private ContainerSingleton(){} private static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>(); public static Object getBean(String className){ synchronized (ioc) { if (!ioc.containsKey(className)) { Object obj = null; try { obj = Class.forName(className).newInstance(); ioc.put(className, obj); } catch (Exception e) { e.printStackTrace(); } return obj; } else { return ioc.get(className); } } } }