当前位置: 首页 > news >正文

网站建设 宁夏淘宝seo搜索引擎原理

网站建设 宁夏,淘宝seo搜索引擎原理,网站开发介绍ppt,wordpress adminlte在上篇文章中,我们讲了单例模式中的饿汉式,今天接着来讲懒汉式。 1.懒汉式单例模式的实现 public class LazySingleton {private static LazySingleton instance null;// 让构造函数为private,这样该类就不会被实例化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, Supplier<T> 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();

       这个创建对象的语句其实是个非原子操作,在极端的多线程环境下,会存在安全问题。对象的创建过程,在执行的时候分解成以下三条指令:

memory=allocate(); 			//1.分配对象的内存空间
ctorInstance(memory);       //2.执行构造方法来初始化对象
instance=memory;			//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 {Class<LazySingleton> clazz = LazySingleton.class;// 获取HungrySingLeton的默认构造函数Constructor<LazySingleton> 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();Class<LazySingleton> clazz = (Class<LazySingleton>) h0.getClass();// 获取HungrySingLeton的默认构造函数Constructor<LazySingleton> 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;Constructor<Singleton> 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;Constructor<Singleton> 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的枚举类型—-枚举的线程安全性及序列化问题

http://www.tj-hxxt.cn/news/94173.html

相关文章:

  • 做公司 网站建设价格关键词完整版免费听
  • 苏州学做网站5118数据分析平台官网
  • 广州网站建设第一公司免费外链代发平台
  • 做非物质文化遗产网站的风险在线培训app
  • 网站全屏轮播怎么做百度西安
  • 苏州外贸公司网站建设流程图品牌推广服务
  • 中国热门网站网站优化关键词价格
  • wordpress建站多少钱semi认证
  • 工程建设承包合同网站排名优化培训课程
  • 网站开发可选的方案有整站营销系统
  • 上海手机响应式网站建设设计百度seo自然优化
  • 微信公众号怎么创建一个公众号深圳外贸seo
  • 网站开发技术要学什么海豹直播nba
  • 政府机构网站建设360指数
  • 怎么制作视频网站成都seo网站qq
  • 网站seo日常工作镇江搜索优化技巧
  • 湖北疾控发布最新通告百度seo优化规则
  • 为网站做一则广告语市场运营和市场营销的区别
  • 重庆网站建设推荐东莞软文推广
  • 电影免费在线观看seo研究中心南宁线下
  • 网站页面不更新网络营销推广平台有哪些
  • 网站简介如何做的有创意如何在百度打广告
  • 用户体验好的网站seo的培训网站哪里好
  • wordpress 上下页导航新网站应该怎么做seo
  • 加强网站的建设与管理什么叫软文
  • 京东网站怎么做网络优化工程师是做什么的
  • 站点创建中国国际新闻
  • 找别人做网站交货时应该注意什么淘宝网官方网站
  • 经营性网站备案网营销案例分析报告模板
  • 汕头网站关键词优化教程成都网站排名优化公司