一、单例模式的应用场景
单例模式(Singleton Pattern)是指确保一个类在任何情况下都绝对只有一个实例,并 提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛。 例如,国家主席、公司 CEO、部门经理等。在 J2EE 标准中,ServletContext、 ServletContextConfig 等;在 Spring 框架应用中 ApplicationContext;数据库的连接 池也都是单例形式。
二、单例模式的实现方式
1、饿汉式
饿汉式单例是在类加载的时候就立即初始化,并且创建单例对象。绝对线程安全,在线 程还没出现以前就是实例化了,不可能存在访问安全问题。 优点:没有加任何的锁、执行效率比较高,在用户体验上来说,比懒汉式更好。 缺点:类加载的时候就初始化,不管用与不用都占着空间,浪费了内存,有可能占着茅 坑不拉屎。
Spring 中 IOC 容器 ApplicationContext 本身就是典型的饿汉式单例。
比较简单的一种写法:
//饿汉式单例
// 它是在类加载的时候就立即初始化,并且创建单例对象
//优点:没有加任何的锁、执行效率比较高,
//在用户体验上来说,比懒汉式更好
//绝对线程安全,在线程还没出现以前就是实例化了,不可能存在访问安全问题
//缺点:类加载的时候就初始化,不管你用还是不用,我都占着空间
//浪费了内存,有可能占着茅坑不拉屎
public class HungrySingle {
private static final HungrySingle hungrySingle=new HungrySingle();
private HungrySingle(){
}
public static HungrySingle getInstance(){
return hungrySingle;
}
}
还有一种写法,是放在静态代码块中:
public class StaticHungrySingle {
private static final StaticHungrySingle instance;
static {
instance = new StaticHungrySingle();
}
private StaticHungrySingle(){
}
public static StaticHungrySingle getInstance(){
return instance;
}
}
2、懒汉式
懒汉式单例的特点是:被外部类调用的时候内部类才会加载,下面看懒汉式单例的简单:
//懒汉式单例
//在外部需要使用的时候才进行实例化
public class SimpleLazySingle {
private SimpleLazySingle(){
}
//静态块,公共内存区域
private static SimpleLazySingle instance=null;
public static SimpleLazySingle getInstance(){
if(instance==null){
instance = new SimpleLazySingle();
}
return instance;
}
}
这种写法虽然简单,但却存在很重的线程安全问题。在多线程下,会出现问题。
既然,有线程问题,那我们最先想到的解决办法即是加锁。
public class SimpleLazySingle {
private SimpleLazySingle(){
}
private static SimpleLazySingle instance=null;
public synchronized static SimpleLazySingle getInstance(){
if(instance==null){
instance = new SimpleLazySingle();
}
return instance;
}
}
此种写法虽然可以解决线程安全问题,但是并发度不高,影响系统的性能。想要解决线程安全问题,加锁是避免不了,又想要提高一点性能,那只能是锁住的范围越小越好。于是,便有了下面这种双重检查的写法:
public class DoubleCheckSingle {
private volatile static DoubleCheckSingle instance = null;
private DoubleCheckSingle(){
}
public static DoubleCheckSingle getInstance(){
if(instance==null){
synchronized (DoubleCheckSingle.class){
if(instance==null){
instance = new DoubleCheckSingle();
}
}
}
return instance;
}
}
但是,用到 synchronized 关键字,总归是要上锁,对程序性能还是存在一定影响的。难道就真的没有更好的方案吗?当然是有的。我们可以从类初始化角度来考虑,看下面的代码,采用静态内部类的方式:
public class StaticInnerSingle {
private StaticInnerSingle(){
}
public static final StaticInnerSingle getInstance(){
return LazyInstance.instance;
}
private static class LazyInstance{
private static final StaticInnerSingle instance=new StaticInnerSingle();
}
}
这种形式兼顾饿汉式的内存浪费,也兼顾 synchronized 性能问题。内部类一定是要在方法调用之前初始化,巧妙地避免了线程安全问题。
但是,用到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();
}
}
静态内部类这种写法为什么既是线程安全的,又能够做到懒加载呢?
虚拟机会保证一个类的类构造器()在多线程环境中被正确的加锁、同步,如果多个线程同时去初始化一个类,那么只会有一个线程去执行这个类的类构造器(),其他线程都需要阻塞等待,直到活动线程执行()方法完毕。
特别需要注意的是,在这种情形下,其他线程虽然会被阻塞,但如果执行()方法的那条线程退出后,其他线程在唤醒之后不会再次进入/执行()方法,因为 在同一个类加载器下,一个类型只会被初始化一次。
静态内部类的特点:外部类加载时不需要加载静态内部类,不被加载则不占用内存(延迟加载)。当外部类调用getInstance方法时,才加载静态内部类,静态属性保证了全局唯一,静态变量初始化保证了线程安全,所以这里的方法没有加synchronized关键字(JVM保证了一个类的 初始化在多线程下被同步加锁)
3、反射破坏单例
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); //false
}catch (Exception e){
e.printStackTrace();
}
}
}
显然,是创建了两个不同的实例。现在,我们在其构造方法中做一些限制,一旦出现多次重复创建,则直接抛出异常。来看下优化后的构造方法,其他代码不变:
private LazyInnerClassSingleton(){
if(LazyHolder.LAZY != null){
throw new RuntimeException("不允许创建多个实例");
}
}
4、序列化破坏单例
当我们将一个单例对象创建好,有时候需要将对象序列化然后写入到磁盘,下次使用时再从磁盘中读取到对象,反序列化转化为内存对象。反序列化后的对象会重新分配内存,即重新创建。那如果序列化的目标的对象为单例对象,就违背了单例模式的初衷,相当于破坏了单例,来看一段代码:
//反序列化时导致单例破坏
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);
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果中,可以看出,反序列化后的对象和手动创建的对象是不一致的,实例化了两次,违背了单例的设计初衷。那么,我们如何保证序列化的情况下也能够实现单例?其实很简单,只需要增加readResolve()方法即可。
private Object readResolve(){
return INSTANCE;
}
至于为什么,希望读者朋友们自己去探索一下ObjectInputStream类的readObject()方法的源码,这里就不再做解释了。
还是解释一句吧:实际上在序列化和反序列化的过程中,对象是被创建了两次。这发生在JVM的层面,是安全的。重写readResolve,只是覆盖了反序列化出来的对象罢了。反序列化的对象也会被GC回收。
5、注册式单例
枚举【推荐】:
注册式单例又称为登记式单例,就是将每一个实例都登记到某一个地方,使用唯一的标识获取实例。注册式单例有两种写法:一种为容器缓存,一种为枚举登记。先来看枚举式单例的写法,来看代码,创建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) {
testSeriable();
}
/**
* 测试序列化破坏单例
*/
public static void testSeriable() {
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());
}catch (Exception e){
e.printStackTrace();
}
}
/**
* 测试反射破坏单例
*/
public static void testReflect(){
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();
}
}
}
通过测试发现,序列化和反射都无法破坏单例。比较推荐此种写法。
通过源码分析,可以看到:
序列化无法破坏单例的原因:枚举类型其实通过类名和Class对象类找到一个唯一的枚举对象。因此,枚举对象不可能被类加载器加载多次。
容器缓存:
//Spring中的做法,就是用这种注册式单例
public class ContainerSingleton {
private ContainerSingleton(){}
private static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>();
public static Object getInstance(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);
}
}
}
}