饿汉式,一上来就创建
//饿汉式单例
public class Hungry {
private Hungry(){
}
private final static Hungry HUNGRY= new Hungry();
public static Hungry getInstance() {
return HUNGRY;
}
//饿汉式可能浪费空间
}
懒汉式,用的才创建
直接这样写,在多线程并发时会有问题,可能导致不是单例的
public class LazyMan {
private LazyMan() {
System.out.println(Thread.currentThread().getName() + "ok");
}
private static LazyMan lazyMan;
public static LazyMan getInstance() {
//懒汉式,用到才创建, 但是在多线程并发时有问题!
if(lazyMan == null) {
lazyMan = new LazyMan();
}
return lazyMan;
}
//模拟多线程并发
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
LazyMan.getInstance();
}).start();
}
}
}
加双重检测锁,volatile 关键字,保证懒汉单例创建
为什么进行双重检测而不是直接在方法上加synchronized?
在方法上加synchronized可以保证单例创建对象,但是对象创建完了,每次都只能一个线程获取对象,显然不合理
第一个检测 lazyMan == null是为了判断对象是否实例化,如果以及实例化了,直接返回对象即可。只有未实例化时才进去竞争锁
第二个检测是因为可能有两个线程都进入资源竞争,第一个线程创建完对象,释放锁,第二个可能继续又创建一个出来违反单例规则
为什么加 volatile 关键字?
因为new 对象这个操作不是原子操作,分为三步:1.分配内存空间, 2.执行构造方法初始化对象, 3.把这个对象指向空间
而且这三步操作在底层可能会出现指令重排, 导致执行顺序并不是123,可能是132。
这样可能会A线程先执行了3对象指向空间不为空了,还没执行2, 然后线程B进来发现对象不为空直接返回还没初始化好的对象,出现错误
volatile 关键字有禁止指令重排的作用
public class LazyMan {
private LazyMan() {
System.out.println(Thread.currentThread().getName() + "ok");
}
private volatile static LazyMan lazyMan;
public static LazyMan getInstance() {
//懒汉式,用到才创建, 但是在多线程并发时有问题!
//双重检测锁
if(lazyMan == null) {
synchronized (LazyMan.class) {
if(lazyMan == null) {
lazyMan = new LazyMan();
// new 不是一个原子操作, 1.分配内存空间, 2.执行构造方法初始化对象, 3.把这个对象指向空间
// 底层是这3步操作,且可能出现指令重排,我们期望123执行,实际可能132执行
// 如果线程A先执行了3, 把对象指向了空间,空间没值,线程B来的时候对象 != null了,导致出现错误, 所以对象得加 volatile 包含禁止指令重排序的含义
}
}
}
return lazyMan;
}
//模拟多线程并发
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(()->{
LazyMan.getInstance();
}).start();
}
}
}
内部类
内部类实现的单例是懒加载的,且线程安全
静态内部类只有在第一次使用的时候才会被加载,由JVM保证其线程安全性,确保该成员变量只能初始化一次
补充:静态属性和静态代码块都是在类加载的时候进行初始化和执行,两者优先级一样,按编码顺序初始化
非静态属性和非静态代码块在构造方法之前执行
静态变量、静态代码块、 非静态变量、普通代码块 执行完毕后执行构造方法
属性加载顺序回顾可以看文章最后一章
public class Holder {
private Holder(){
}
public static Holder getInstance() {
return InnerClass.HOLDER;
}
public static class InnerClass {
private static final Holder HOLDER = new Holder();
}
}
用反射破坏单例及相应对抗方式
使用单例破坏构造器的私有性
public static void main(String[] args) throws Exception {
LazyMan instance1 = LazyMan.getInstance();
//通过反射拿到无参构造器
Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
constructor.setAccessible(true); //破坏构造器私有
LazyMan instance2 = constructor.newInstance();
System.out.println(instance1 == instance2); //false
}
防止反射的对抗, 构造器方法:
private LazyMan() {
synchronized (LazyMan.class) {
if(lazyMan != null) {
throw new RuntimeException("不要试图使用反射破坏单例");
}
}
}
用反射先获取无参构造器, 导致 if(lazyMan == null) 条件失效, 还是一直可以创建对象
public static void main(String[] args) throws Exception {
//通过反射拿到无参构造器
Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
constructor.setAccessible(true);
LazyMan instance2 = constructor.newInstance();
LazyMan instance3 = constructor.newInstance();
System.out.println(instance2 == instance3); //false
}
再次防止反射的对抗, 创建一个静态变量作为标志位,构造器方法:
//创建一个谁都不知道的静态变量, 作为判断条件
private static boolean lych4 = false;
private LazyMan() {
synchronized (LazyMan.class) {
if(!lych4) {
lych4 = true;
}else {
throw new RuntimeException("不要试图使用反射破坏单例");
}
}
}
假设用某种方法获取到了你标志位变量的名字,然后用反射获取到这个属性,破坏其私有,手动改变其值,破坏单例
public static void main(String[] args) throws Exception {
Field lych4 = LazyMan.class.getDeclaredField("lych4");
lych4.setAccessible(true); //破坏属性的私有性
Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
constructor.setAccessible(true);
LazyMan instance1 = constructor.newInstance();
lych4.set(instance1, false); //设置lych4的值
LazyMan instance2 = constructor.newInstance();
System.out.println(instance1 == instance2);
}
到底怎么办呢?
真正解决,实现防止被破坏的单例
先看反射的构造器 newInstance() 方法源码
可以发现如果类是一个枚举类(ENUM)的话,会抛出异常:“不能用反射创建枚举对象”
所有如果单例模式不想被反射破坏,终极武器就是使用枚举对象
测试:
创建枚举类
/**
* enum 本身也是一个class类
*/
public enum EnumSingle {
INSTANCE;
public EnumSingle getInstance() {
return INSTANCE;
}
}
尝试反射破坏枚举类, 查看EnumSingle 的class文件发现里面有一个空参构造器,
尝试通过反射获取空参构造器去创建对象,:
public static void main(String[] args) throws Exception {
EnumSingle instance1 = EnumSingle.INSTANCE;
Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
declaredConstructor.setAccessible(true);
EnumSingle instance2 = declaredConstructor.newInstance();
System.out.println(instance1 == instance2);
}
报错:Exception in thread “main” java.lang.NoSuchMethodException: cn.lych4.sigle.EnumSingle.()
报错说没有这个方法(构造器), 而不是报的 “不能用反射创建枚举对象”。不太对劲,这说明枚举类里面没有空参构造器。class文件显示的Java代码不太对
经过专业软件,把class文件转为Java文件发现枚举类里面是有参构造
发现有参构造,那我们通过反射获取有参构造器,尝试用反射破坏单例:
public static void main(String[] args) throws Exception {
EnumSingle instance1 = EnumSingle.INSTANCE;
Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
declaredConstructor.setAccessible(true);
EnumSingle instance2 = declaredConstructor.newInstance();
System.out.println(instance1 == instance2);
}
报错:Cannot reflectively create enum objects at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
成功报了:“不能用反射创建枚举对象”这个错误,说明确实不能用反射来破坏枚举类的单例。
如果发现有错误的地方,欢迎大家提出批评指正
💖致力于分享记录各种知识干货,关注我,让我们一起进步,互相学习,不断创作更优秀的文章。
💖💖不要忘了三连哦 👍 💬 ⭐️ , 会回访的