网站建设 中企动力扬州,wordpress小机巧,wordpress查询分页,百度竞价排名及自动竞价功能在上篇文章中#xff0c;我们讲了单例模式中的饿汉式#xff0c;今天接着来讲懒汉式。
1.懒汉式单例模式的实现
public class LazySingleton {private static LazySingleton instance null;// 让构造函数为private#xff0c;这样该类就不会被实例化private LazySingleto… 在上篇文章中我们讲了单例模式中的饿汉式今天接着来讲懒汉式。
1.懒汉式单例模式的实现
public class LazySingleton {private static LazySingleton instance null;// 让构造函数为private这样该类就不会被实例化private LazySingleton() {}public static LazySingleton getInstance() {if (instance null) {instance new LazySingleton();}return instance;}public long getRamAddress() {return this.hashCode();}
} 懒汉式的特点在于有需要时才实例化。
2.懒汉式线程安全 在多线程的环境下getInstance方法会导致线程不安全。因为在getInstance时可能A、B两个线程几乎同时进入在A实例化未完成的情况下B判断实例仍然为null因此继续实例化这样有实例化了两个不同的对象明显违背了单例的初衷。这里可以稍微验证一下线程安全问题为了方便验证在getInstance让当前线程sleep public static LazySingleton getInstance() {if (instance null) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}instance new LazySingleton();}return instance;} 测试代码 /*** 公共方法在多线程环境下测试单例避免重复编写测试代码* param threadCount 线程数* param func 函数用于获取单例* param T*/public static T void singLetonMultiThread(int threadCount, SupplierT func) {ExecutorService executorService Executors.newFixedThreadPool(threadCount);IntStream.range(0, threadCount).forEach(i - {executorService.submit(() - {System.out.println(func.get());});});// 等线程全部执行完后关闭线程池executorService.shutdown();try {executorService.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);} catch (InterruptedException e) {e.printStackTrace();}}public static void lazySingLetonTest() {Supplier func () - LazySingleton.getInstance();singLetonMultiThread(10, func);}
测试结果如下 十个线程里出现了8个不同的对象
2.1 双重检查锁 我们需要改进一下getInstance方法考虑到效率问题我们不想直接在getInstance方法上加锁因为这种方式下每次调用getInstance()时都需要进行线程锁定判断在多线程高并发访问环境中将会导致系统性能大大降低。于是我们得在判断实例是否为空时加锁并且进行双重检查 public static LazySingleton getInstance() {if (instance null) {synchronized (LazySingleton.class) {// 这里需要再判断一次因为可能有其它线程已经创建实例if (instance null) {instance new LazySingleton();}}}return instance;} 这样看起来似乎是解决了问题了。
2.2 指令重排 但这还有瑕疵。对于
instance new LazySingleton(); 这个创建对象的语句其实是个非原子操作在极端的多线程环境下会存在安全问题。对象的创建过程在执行的时候分解成以下三条指令
memoryallocate(); //1.分配对象的内存空间
ctorInstance(memory); //2.执行构造方法来初始化对象
instancememory; //3.设置instance指向刚分配的内存地址正常执行顺序应该是1-2-3但可能指令会被重排序为1-3-2也就是说2、3步有可能发生指令重排导致重排序因为synchronized只能保证有序性但无法禁止指令重排。假设有两个线程A、B在双重检查锁内从cpu时间片上的执行顺序如下 A线程执行完3还没执行2虽然分配了内存空间已但是还没初始化对象而此时B线程进来判断(instance null)由于instance已经指向了内存空间所以instance ! null于是直接返回了对象但此时对象还未初始化。这样一来线程B将得到一个还没有被初始化的对象。 为了防止指令重排需在声明instance对象时加上volatile关键词
public class LazySingleton {// volatile确保本条指令不会因编译器的优化而省略且要求每次直接读值private static volatile LazySingleton instance null;// 让构造函数为private这样该类就不会被实例化private LazySingleton() {//System.out.println(懒汉式单例初始化);}public static LazySingleton getInstance() {if (instance null) {synchronized (LazySingleton.class) {// 这里需要再判断一次因为可能有其它线程已经创建实例if (instance null) {try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}instance new LazySingleton();}}}return instance;}public long getRamAddress() {return this.hashCode();}
} volatile关键词具备以下功能: 1. 避免编译器将变量缓存在寄存器里 2. 避免编译器调整代码执行的顺序 使用volatile声明的变量可以强制屏蔽编译器和JIT的优化工作能够防止双重检查锁的指令重排。
3.反射破坏单例 正如在上篇文章饿汉式单例中所说的那样懒汉式同样有反射的问题。我们采用跟懒汉式一样的方法常识防止破坏单例
public class LazySingleton {private static volatile LazySingleton instance null;// 让构造函数为private这样该类就不会被实例化private LazySingleton() {//System.out.println(懒汉式单例初始化);synchronized (LazySingleton.class) {if(instance ! null){throw new RuntimeException(单例构造器禁止反射调用);}}}public static LazySingleton getInstance() {if (instance null) {synchronized (LazySingleton.class) {// 这里需要再判断一次因为可能有其它线程已经创建实例if (instance null) {instance new LazySingleton();}}}return instance;}public long getRamAddress() {return this.hashCode();}
} 再测试一下看看 public static void LazySingletonReflectionTest() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {ClassLazySingleton clazz LazySingleton.class;// 获取HungrySingLeton的默认构造函数ConstructorLazySingleton constructor clazz.getDeclaredConstructor();constructor.setAccessible(true);// 调用默认构造函数创建实例LazySingleton h1 constructor.newInstance();LazySingleton h2 constructor.newInstance();System.out.println(h1.getRamAddress());System.out.println(h2.getRamAddress());} 运行结果 没用因为在类加载的时候懒汉式单例根本就没有对单例进行初始化然后反射通过构造函数获取单例获取的对象都是不同的所以没法防止反射破坏。当然如果是先通过getInstance获取单例再反射这种情况下就可以防止反射如 public static void reflectionTest2() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {LazySingleton h0 LazySingleton.getInstance();ClassLazySingleton clazz (ClassLazySingleton) h0.getClass();// 获取HungrySingLeton的默认构造函数ConstructorLazySingleton constructor clazz.getDeclaredConstructor();constructor.setAccessible(true);// 调用默认构造函数创建实例LazySingleton h1 constructor.newInstance();System.out.println(h0.getRamAddress());System.out.println(h1.getRamAddress());} 懒汉式单例对这个问题没有好的解决办法。
4.优雅的单例实现——枚举 单例模式存在线程安全、反射、序列化漏洞的问题虽然可以想办法解决但代码也比较臃肿了。换个角度可以用枚举来实现去规避这些问题。
public enum Singleton {INSTANCE;public void doSomething() {System.out.println(这里实现自己的业务);}
}
4.1 枚举单例防止反射 先测试一下枚举单例的反射 public static void enumSingletonRlectionTest() throws NoSuchMethodException,IllegalAccessException, InvocationTargetException, InstantiationException {Singleton instance1 Singleton.INSTANCE;ConstructorSingleton declaredConstructor Singleton.class.getDeclaredConstructor(null);declaredConstructor.setAccessible(true);//java.lang.NoSuchMethodException: com.kuang.single.EnumSingle.init()Singleton instance2 declaredConstructor.newInstance();System.out.println(instance1);System.out.println(instance2);} 结果抛出异常 没有构造函数Singleton.init() 这并非防止了反射。枚举Enum是个抽象类它有个构造函数
protected Enum(String name, int ordinal) {this.name name;this.ordinal ordinal;
} 我们定义了枚举类单例实际上就是继承了Enum所以会有String.class,int.class的构造器测试方法改造下 public static void enumSingletonRlectionTest() throws NoSuchMethodException,IllegalAccessException, InvocationTargetException, InstantiationException {Singleton instance1 Singleton.INSTANCE;ConstructorSingleton declaredConstructor Singleton.class.getDeclaredConstructor(String.class,int.class);declaredConstructor.setAccessible(true);//java.lang.NoSuchMethodException: com.kuang.single.EnumSingle.init()Singleton instance2 declaredConstructor.newInstance();System.out.println(instance1);System.out.println(instance2);} 结果如下 Cannot reflectively create enum objects(无法以反射方式创建枚举对象)可以防止反射因为反射在通过构造函数的newInstance方法创建对象时会检查该类是否ENUM修饰如果是则抛出异常反射失败。所以枚举类不能通过反射来创建对象 4.2 枚举单例避免序列化问题 普通的Java类的反序列化过程中会通过反射调用类的默认构造函数来初始化对象。所以即使单例中构造函数是私有的也会被反射给破坏掉。由于反序列化后的对象是重新new出来的所以这就破坏了单例必须新增readResolve方法才能防止破坏。 但是枚举的反序列化并不是通过反射实现的。在序列化时Java仅仅是将枚举对象的name属性输出到结果中反序列化时则通过java.lang.Enum的valueOf(String name) 方法根据名字查找内存中是否已经有该对象若找到了就会直接使用它如果不存在就会抛出异常。同时。编译器不允许任何对这种序列化机制的定制因此禁用了writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法。这样一来序列化的方式就无法创建新的对象了也就不会发生由于反序列化导致的单例破坏问题。 实际测试一下 public static void enumSingletonSerializable() {ObjectOutputStream oos null;ObjectInputStream ois null;try {File file new File(d:\\Singleton.txt);// -----------序列化-------------// 创建输出流oos new ObjectOutputStream(new FileOutputStream(file));//将单例对象写到文件中 序列化oos.writeObject(Singleton.INSTANCE);oos.flush();// -----------反序列化-------------// 从文件读取单例对象ois new ObjectInputStream(new FileInputStream(file));// 反序列化得到对象singLetonSingleton singLeton (Singleton)ois.readObject();System.out.println(singLeton Singleton.INSTANCE); //falsefile.deleteOnExit();} catch (Exception e) {e.printStackTrace();} finally {try {if(oos ! null) {oos.close();}if(ois ! null) {ois.close();}} catch (IOException e) {e.printStackTrace();}}} 测试结果 4.3 多线程安全 当我们使用enmu来定义一个枚举类型的时候编译器会自动帮我们创建一个final类型的类继承Enum类所以枚举类型不能被继承同时编译器所创建的类中属性和方法也都是都是static类型的因为static类型的属性会在类被加载之后被初始化。当一个Java类第一次被真正使用到的时候静态资源被初始化、Java类的加载和初始化过程都是线程安全的因为虚拟机在加载枚举的类的时候会使用ClassLoader的loadClass方法而这个方法使用同步代码块保证了线程安全。所以创建一个enum类型是线程安全的。所以创建一个enum类型是线程安全的。 基于前面的分析单例类的线程安全问题主要就是单例初始化过程中的线程安全问题。而由于枚举的以上特性枚举实现的单例是天生线程安全的。所以用枚举实现的单例是最好的方式 参考文章
两种单例模式详解内含懒汉式的双重校验锁详解为什么我墙裂建议大家使用枚举来实现单例
深度分析Java的枚举类型—-枚举的线程安全性及序列化问题
