单例模式简介
- 核心作用：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
- 常见场景：
- Windows的任务管理器
- Windows回收站
- 项目中，读取配置文件的工具类
- 网站的计数器一般也会采用单例模式，可以保证同步
- 数据库连接池的设计一般也是单例模式
- 在Servlet编程中，每个Servlet也是单例的
- 在Spring中，每个Bean默认就是单例的
常见五种单例模式的实现方式
饿汉式
// 饿汉式
public class Hungry {
// 1.私有化构造器
private Hungry() {
}
// 2.类初始化的时候，立即加载该对象
private static Hungry instance = new Hungry();
// 3.提供获取该对象的方法，没有synchronized，效率高
public static Hungry getInstance() {
return instance;
}
}
- 饿汉式是最简单的单例模式的写法，保证了线程的安全，执行效率高，但不能延时加载。
- 但饿汉式也存在一些问题，比如，在单例中要创建大量的数据。
public class Hungry {
private byte[] data1 = new byte[1024];
private byte[] data2 = new byte[1024];
private byte[] data3 = new byte[1024];
private byte[] data4 = new byte[1024];
private Hungry() {
}
private final static Hungry hungry = new Hungry();
public static Hungry getInstance() {
return hungry;
}
}
-
在Hungry类中，定义了四个byte数组，当代码一运行，这四个数组就被初始化，并且放入到内存中，如果长时间没有使用
getInstance()方法，不需要Hungry类的对象，就会对内存造成一种浪费。 -
我们希望只有在使用
getInstance()方法时，才会去初始化单例类，加载单例类中的数据。因此，有了第二种单例模式：懒汉式。
懒汉式
// 懒汉式
public class LazyMan {
// 1.私有化构造器
private LazyMan() {}
// 2.类初始化的时候，不立即加载该对象
private static LazyMan instance;
// 3.提供获取该对象的方法，有synchronized，效率较低
public static synchronized LazyMan getInstance() {
if (instance == null) {
instance = new LazyMan();
}
return instance;
}
}
- 懒汉式，保证线程安全，可以延时加载，但调用效率不高（获取该实例的方法上加了synchronized）。
DCL懒汉式
public class LazyMan {
private LazyMan() {
}
// 类初始化的时候，不立即加载该对象
private static LazyMan lazyMan;
// 双重检查
public static LazyMan getInstance() {
if (lazyMan == null) {
// 静态同步代码块，锁对象为本类的class属性
/*
加锁是为了确保第一个拿到锁对象的线程创建对象后，
第二个拿到锁对象的线程无需再创建新对象
*/
synchronized (LazyMan.class) {
if (lazyMan == null) {
lazyMan = new LazyMan();
}
}
}
return lazyMan;
}
}
- Double Checked Lock 双重锁，优化了懒汉式同步慢的问题，由于JVM底层内部模型原因，偶尔会出现问题，不建议使用
-
DCL懒汉式的单例，保证了线程的安全性，又符合懒加载，只有在用到的时候，才回去初始化，调用效率也比较高，但是这种写法在极端情况下，还是可能会有一定的问题。
-
因为
lazyMan = new LazyMan();不是原子操作，至少会经过以下三个步骤：
- 分配内存
- 执行构造方法
- 指向地址
-
由于指令重排，导致A线程执行
lazyMan = new LazyMan();时，可能先执行了第三步（还没有执行第二步），此时B线程又进来了，发现 lazyMan不为空，直接返回了lazyMan，并且后面使用了返回的 lazyMan，由于此时线程A还没有第二部，导致此时lazyMan还不完整，可能会有一些意象不到的错误，所以就有了下面一种单例模式。 -
这种单例模式只是在上面DCL单例模式增加一个volatile关键字来避免指令重排：
public class LazyMan {
private LazyMan() {
}
// 增加volatile关键字，避免指令的重排，保证它的原子性和一致性
private volatile static LazyMan lazyMan;
// 双重检查
public static LazyMan getInstance() {
if (lazyMan == null) {
// 静态同步代码块，锁对象为本类的class属性
/*
加锁是为了确保第一个拿到锁对象的线程创建对象后，
第二个拿到锁对象的线程无需再创建新对象
*/
synchronized (LazyMan.class) {
if (lazyMan == null) {
lazyMan = new LazyMan();
}
}
}
return lazyMan;
}
}
饿汉式改进（静态内部类式）
- 还有这种方式是第一种饿汉式的改进版本，同样也是在类中定义static变量的对象，并且直接初始化，不过是移到了静态内部类中，十分巧妙。既保证了线程的安全性，同时又满足了懒加载。
// 静态内部类实现
public class Holder {
// 1.私有化构造方法
private Holder() {
}
// 2.私有静态内部类
private static class InnerClass {
private static final Holder instance = new Holder();
}
// 3.获取该对象的方法
public static Holder getInstance() {
return InnerClass.instance;
}
}
枚举单例
public enum EnumSingleton {
INSTANCE;
public EnumSingleton getInstance(){
return INSTANCE;
}
}
- 枚举类型是纯天然的单例模式
- 线程安全，调用效率高，但不能延时加载
- 枚举类型是目前最推荐的单例模式的写法，因为足够简单，不需要自己开发去保证线程的安全性，同时可以有效的防止反射来破化我们的单例模式
- 在
newInstance的源码中：
- 如果我们使用反射创建枚举类型对象，就会直接抛出异常
防止反射破坏单例模式
// DCL懒汉式
public class LazyMan {
private LazyMan() {}
// 2.类初始化时，不立即加载该对象
// 增加volatile关键字，避免指令的重排，保证它的原子性和一致性
private volatile static LazyMan instance;
// 3.获取该对象的方法
public static LazyMan getInstance() {
if (instance == null) {
// 静态同步代码块
// 和其他线程竞争本类的锁
synchronized (LazyMan.class) {
if (instance == null) {
instance = new LazyMan();
}
}
}
return instance;
}
}
class LazyManTest {
public static void main(String[] args) throws Exception {
// 调用静态方法创建
LazyMan instance1 = LazyMan.getInstance();
// 使用反射方式创建
Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor();
declaredConstructor.setAccessible(true);
LazyMan instance2 = declaredConstructor.newInstance();
System.out.println(instance1 == instance2); // false
}
}
问题：当我们调用懒汉模式的静态方法创建了一个单例对象，又使用反射方式创建了一个对象，通过比较得出：两个对象的引用不是同一个引用，这就用反射破坏了我们的单例模式。
解决方式：在私有构造器中进行一个判断，如果 lazyMan 不为空，说明 lazyMan 已经被创建过了，如果正常调用 getInstance 方法，是不会出现这种事情的，所以直接抛出异常
public class LazyMan {
private LazyMan() {
synchronized (LazyMan.class) {
if (lazyMan != null) {
throw new RuntimeException("不要试图用反射破坏单例模式");
}
}
}
private volatile static LazyMan lazyMan;
public static LazyMan getInstance() {
if (lazyMan == null) {
synchronized (LazyMan.class) {
if (lazyMan == null) {
lazyMan = new LazyMan();
}
}
}
return lazyMan;
}
}
但是这种写法还是有问题：在上面我们先是正常调用了 getInstance 方法，创建了LazyMan对象，而后第二次用反射创建对象，这样私有构造函数里的判断就起到作用，如果我们两次都是用反射创建对象呢？
问题：如果两次都用反射创建对象，那么还是会创建两个不同的对象，依旧破坏了单例模式。
原因：private volatile static LazyMan lazyMan;这条语句中的lazyMan引用没有被赋值对象的地址，也就是说lazyMan对象没有被构造方法创建，在内存中没有用getInstance方法去初始化lazyMan引用，此时的lazyMan引用一直为null，在私有构造器中的判断就不起作用了。
解决方式：定义一个静态布尔类型的flag变量，初始值为false，私有构造函数里面做一个判断，当第一次创建对象时，flag == false（肯定的），就把 flag 置为 true；当第二次创建对象时，flag已经为ture，这就说明出现问题了，正常的调用是不会第二次跑到私有构造方法中的，所以抛出异常。
public class LazyMan {
private static boolean flag = false;
private LazyMan() {
synchronized (LazyMan.class) {
if (flag == false) {
flag = true;
} else {
throw new RuntimeException("不要试图用反射破坏单例模式");
}
}
}
private volatile static LazyMan lazyMan;
public static LazyMan getInstance() {
if (lazyMan == null) {
synchronized (LazyMan.class) {
if (lazyMan == null) {
lazyMan = new LazyMan();
}
}
}
return lazyMan;
}
}
看起来很美好，但是还是不能阻止反射破坏单例模式，因为可以用反射破坏flag的值。
并没有一个很好的方案去避免反射破坏单例模式，但枚举类型是纯天然防止使用反射创建对象的，如果枚举去newInstance就直接抛出异常了。