设计模式（一）------ 单例模式
一、设计模式分类
创建型模式
- 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式
结构型模式
- 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式
行为型模式
- 模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。
二、单例模式
核心作用：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
单例模式优点：由于单例模式只生成一个实例，减少系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置文件，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留在内存的方式解决。
常见的五种单例模式实现方式：
饿汉式（线程安全，调用效率高。但是不能延时加载）
懒汉式（线程安全，调用效率不高。但是可以延时加载）
双层检测锁式（由于JVM底层内部模型原因，偶尔出现问题，不建议使用）
静态内部类式（线程安全、调用效率高，可以延时加载）
枚举单例（线程安全，调用效率高，不能延时加载，天然的防止反射和反序列化漏洞）
1、饿汉式
/**
* 饿汉式单例模式
* static 变量会在类加载时初始化。JVM保证只会加载一次该类, 肯定不会发生并发访问的问题
*/
public class SingleDemo1
{
// 类初始化时加载这个对象
private static /*final*/ SingleDemo1 INSTANCE = new SingleDemo1();
// 构造方法私有
private SingleDemo1()
{}
// 方法没有同步, 调用效率高
public static SingleDemo1 getInstance()
{
return INSTANCE;
}
}
2、懒汉式
/**
* 懒汉式
* 延时加载, 资源利用率高；
* getInstance() 增加同步方法, 调用效率低
*/
public class SingleDemo2
{
private static SingleDemo2 singleDemo2;
// 构造方法私有化
private SingleDemo2()
{}
// 加synchronized方法同步, 调用效率低
public static synchronized SingleDemo2 getInstance()
{
if(null == singleDemo2)
{
singleDemo2 = new SingleDemo2();
}
return singleDemo2;
}
}
3、双重检测锁模式
4、静态内部类实现单例模式
/**
* 静态内部类实现单例模式
* 线程安全, 懒加载, 调用效率高
*/
public class SingleDemo3
{
// 静态内部类
private static class SingleDemoInner
{
//类初始化时加载, static final 保证内存中只有一个这样实例存在, 而且只能被赋值一次
private static final SingleDemo3 INSTANCE = new SingleDemo3();
}
// 构造方法私有化
private SingleDemo3()
{}
// 没有同步, 调用效率高
public static SingleDemo3 getInstance()
{
return SingleDemoInner.INSTANCE;
}
}
5、枚举类
/**
* 枚举类实现单例模式 (不能延时加载)
* 枚举是天然的单例, 由JVM从根本上提供保障;
* 避免通过反射和反序列化的漏洞!
*/
public enum SingleDemo4
{
// 定义一个枚举的元素, 它就代表了Singleton的一个实例
INSTANCE;
//单例可以有自己的操作
public void singletonOperation()
{
//功能处理
}
}
6、使用反射或反序列化可以破解上面的懒汉式、饿汉式、双重检测锁模式（不建议使用）、静态内部类式实现的单例。
（1）测试反射破解：
/**
* 测试反射破解
*/
public class MainTest
{
public static void main(String[] args) throws Exception
{
// 通过反射方式构造多个对象
Class<SingleDemo1> clazz = (Class<SingleDemo1>) Class.forName("com.yufeng.single.SingleDemo1");
Constructor<SingleDemo1> constructor= clazz.getDeclaredConstructor(null);
constructor.setAccessible(true); //跳过权限检查
SingleDemo1 demo3 = constructor.newInstance();
SingleDemo1 demo4 = constructor.newInstance();
System.out.println(demo3);
System.out.println(demo4);
}
}
结果：
com.yufeng.single.SingleDemo1@14ae5a5
com.yufeng.single.SingleDemo1@7f31245a
（2）测试反序列化破解（SingleDemo1 实现 Serializable 接口）
/**
* 测试反序列化破解
*/
public class MainTest
{
public static void main(String[] args) throws Exception
{
// 通过反序列化构造多个对象
SingleDemo1 a1 = SingleDemo1.getInstance(); //序列化的类要实现 Serializable 接口
System.out.println(a1);
//序列化
FileOutputStream fos = new FileOutputStream("d:/a.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(a1);
oos.close();
fos.close();
//反序列化
FileInputStream fis = new FileInputStream("d:/a.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
SingleDemo1 a2 = (SingleDemo1) ois.readObject();
System.out.println(a2);
}
}
解决反射和反序列化破解单例的问题
以懒汉式为例，如下：
/**
* 解决反射和反序列化破解单例的问题
*/
public class SingleDemo5 implements Serializable
{
private static /*final*/ SingleDemo5 INSTANCE = new SingleDemo5();
// 构造方法私有
private SingleDemo5()
{
//防止反射破坏单例 可以在构造方法中手动抛出异常，解决反射破解的问题
if(null != INSTANCE)
{
throw new RuntimeException("单例模式, 不可使用反射创建实例.");
}
}
// 方法没有同步, 调用效率高
public static SingleDemo5 getInstance()
{
return INSTANCE;
}
// 可以通过readResolve()方法防止反序列获得到不同的对象
// 反序列化时, 若定义了readReolve()方法, 直接返回此方法指定的对象, 而不需要再单独创建新对象
private Object readResolve() throws ObjectStreamException
{
return INSTANCE;
}
}
三、五种实现方式在多线程下的效率
