3d建模师可以自学吗,sem优化托管,正规的编程培训机构,广州市国外网站建设平台模式定义#xff1a;保证一个类只有一个实例#xff0c;并且提供一个全局访问点#xff0c;时一种创建型模式
使用场景#xff1a;重量级的对象#xff0c;不需要多个实例#xff0c;如线程池#xff0c;数据库连接池
单例设计模式的实现
1.懒汉模式#xff1a;延迟…模式定义保证一个类只有一个实例并且提供一个全局访问点时一种创建型模式
使用场景重量级的对象不需要多个实例如线程池数据库连接池
单例设计模式的实现
1.懒汉模式延迟加载只有真正用到的时候才去做实例化
public class LazySingletonTest {public static void main(String[] args) {LazySingleton instance LazySingleton.getInstance();LazySingleton instance1 LazySingleton.getInstance();System.out.println(instance instance1);}
}
class LazySingleton{private static LazySingleton instance;public static LazySingleton getInstance(){if (instance null){instance new LazySingleton();}return instance;}
}这是懒汉模式最基本的概念就是什么时候需要了再什么时候创建
但是这样设计可能会有线程安全问题同一时间两个访问就可能会new出来两个instance 最简单的解决思路就是给getInstance上锁 public synchronized static LazySingleton getInstance(){if (instance null){instance new LazySingleton();}return instance;}新出现的问题就是方法每次都加锁完全没有必要属于是性能浪费 那么可以进行一个锁的延迟 public synchronized static LazySingleton getInstance(){if (instance null){synchronized (LazySingleton.class){if(instance null){ //还是防止第一次初始化两个线程竞争instance new LazySingleton();}}}return instance;}从字节码来说JIT或者CPU会再instance new LazySingleton();这行代码的初始化和引用赋值进行重排序 在引用复制而没有初始化的中间又来了一个线程访问发现instance已经赋值了他就会直接拿到那个静态的instance而不是进入if这就会导致他虽然拿到了但是拿到的instance是空的因为没有初始化 可以用volatile防止指令重排序来解决这个问题 private volatile static LazySingleton instance;2.饿汉模式
类加载的初始化阶段就完成了类的初始化本质上就是借助于jvm类的加载机制保证实例的唯一性
public class hungrySingletonTest {public static void main(String[] args) {HungrySingleton instance HungrySingleton.getInstance();HungrySingleton instance1 HungrySingleton.getInstance();System.out.println(instance1 instance);}
}class HungrySingleton{private static HungrySingleton instance new HungrySingleton();//不允许外部进行实例化private HungrySingleton(){}public static HungrySingleton getInstance(){return instance;}
}饿汉模式赋值是在类加载的初始化阶段完成的而类加载的是在真正的使用对应的类时才会触发初始化
3. 静态内部类模式
本质也是通过类加载的机制实现的懒加载的方式
class InnerClassSingleton{private static class InnerClassHolder{private static InnerClassSingleton instance new InnerClassSingleton();}private InnerClassSingleton(){}public static InnerClassSingleton getInstance(){return InnerClassHolder.instance;}
}与饿汉模式稍有差异饿汉模式是在类加载的时候就直接把instance初始化了而静态内部类的方式下不调用getInstance()这个方法是不会对里面的静态内部类InnerClassHolder进行加载instance也不会初始化所以也是一种懒加载 他的本质上也是利用类的加载机制来保证类的线程安全
防止反射攻击
这种单例的设计模式都是可能通过反射来获取新的实例对象的如
public class InnerClassSingletonTest {public static void main(String[] args) throws Exception {//通过反射获取他的构造器然后通过构造器getInstance一个对象ConstructorInnerClassSingleton declaredConstructor InnerClassSingleton.class.getDeclaredConstructor();declaredConstructor.setAccessible(true);InnerClassSingleton innerClassSingleton declaredConstructor.newInstance();//正常方法获取对象InnerClassSingleton instance InnerClassSingleton.getInstance();//返回flaseSystem.out.println(instance innerClassSingleton);}
}class InnerClassSingleton{private static class InnerClassHolder{private static InnerClassSingleton instance new InnerClassSingleton();}private InnerClassSingleton(){}public static InnerClassSingleton getInstance(){return InnerClassHolder.instance;}
}
下面给出防范措施如饿汉模式和静态内部类的模式下可以在构造器内进行判断是否有过初始化如果有就说明这是通过反射等非正常手段获取的instance的然后抛出异常 class InnerClassSingleton{private static class InnerClassHolder{private static InnerClassSingleton instance new InnerClassSingleton();}private InnerClassSingleton(){if (InnerClassHolder.instance ! null) {throw new RuntimeException(单例不允许多个实例);}}public static InnerClassSingleton getInstance(){return InnerClassHolder.instance;}
}很明显懒汉模式没有办法防止这种反射
枚举类型
首先我们看一下反射中constructor的newInstance()方法源码 CallerSensitivepublic T newInstance(Object ... initargs)throws InstantiationException, IllegalAccessException,IllegalArgumentException, InvocationTargetException{if (!override) {if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {Class? caller Reflection.getCallerClass();checkAccess(caller, clazz, null, modifiers);}}//----------------//由这行代码可知如果使用反射访问的类是个枚举类那么就会抛出异常//由这个思路可以用枚举来防止反射攻击if ((clazz.getModifiers() Modifier.ENUM) ! 0)throw new IllegalArgumentException(Cannot reflectively create enum objects);ConstructorAccessor ca constructorAccessor; // read volatileif (ca null) {ca acquireConstructorAccessor();}SuppressWarnings(unchecked)T inst (T) ca.newInstance(initargs);return inst;}下面是用枚举设计的最基础的单例模式
public class EnumSingletonTest {public static void main(String[] args) {EnumSingleton instance EnumSingleton.INSTANCE;EnumSingleton instance1 EnumSingleton.INSTANCE;System.out.println(instance1 instance);}
}
enum EnumSingleton{INSTANCE;public void print(){System.out.println(this.hashCode());}
}我们通过翻看字节码文件可以看到 enum类其实是继承了java.lang.Enum 可以看到Enum的构造器 所以要访问他的话反射里面也要拿到这个构造器 最后根据构造器来newInstance出来 可以看到很好的防止反射进行攻击
序列化的单例
实际工作中我们需要类可以序列化(如implements Serializable)之后进行数据传输 一个Instance在写入又读取的操作以后读取不会走构造器所以就会生成一个新的实例破坏了单例的形式
//在静态内部类那个类做了个测试
public class InnerClassSingletonTest {public static void main(String[] args) throws Exception {InnerClassSingleton instance InnerClassSingleton.getInstance();ObjectOutputStream oos new ObjectOutputStream(new FileOutputStream(testSerializable));oos.writeObject(instance);oos.close();ObjectInputStream ois new ObjectInputStream(new FileInputStream(testSerializable));InnerClassSingleton instance1 (InnerClassSingleton)ois.readObject();ois.close();System.out.println(instance1 instance); //输出false}
}class InnerClassSingleton implements Serializable {private static class InnerClassHolder{private static InnerClassSingleton instance new InnerClassSingleton();}private InnerClassSingleton(){if (InnerClassHolder.instance ! null) {throw new RuntimeException(单例不允许多个实例);}}public static InnerClassSingleton getInstance(){return InnerClassHolder.instance;}
}
来看看官方给出的解决方案 意思就是实现一个特殊的方法然后返回你想要的那个单例就行了
public class InnerClassSingletonTest {public static void main(String[] args) throws Exception {InnerClassSingleton instance InnerClassSingleton.getInstance();ObjectOutputStream oos new ObjectOutputStream(new FileOutputStream(testSerializable));oos.writeObject(instance);ObjectInputStream ois new ObjectInputStream(new FileInputStream(testSerializable));InnerClassSingleton instance1 (InnerClassSingleton)ois.readObject();System.out.println(instance1 instance);}
}class InnerClassSingleton implements Serializable {static final long serialVersionUID 42L; //序列化版本号private static class InnerClassHolder{private static InnerClassSingleton instance new InnerClassSingleton();}private InnerClassSingleton(){if (InnerClassHolder.instance ! null) {throw new RuntimeException(单例不允许多个实例);}}public static InnerClassSingleton getInstance(){return InnerClassHolder.instance;}//实现的readResolve方法Object readResolve() throws ObjectStreamException{return InnerClassHolder.instance;}
}
PS切记要写个版本号不然报错捏
