文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

Java关于延迟加载的一些应用实践

2024-12-03 11:57

关注

 代码中的很多操作都是Eager的,比如在发生方法调用的时候,参数会立即被求值。总体而言,使用Eager方式让编码本身更加简单,然而使用Lazy的方式通常而言,即意味着更好的效率。

延迟初始化

一般有几种延迟初始化的场景:

在Java8中引入的lambda对于我们实现延迟操作提供很大的便捷性,如Stream、Supplier等,下面介绍几个例子。

Lambda

Supplier

通过调用get()方法来实现具体对象的计算和生成并返回,而不是在定义Supplier的时候计算,从而达到了_延迟初始化_的目的。但是在使用 中往往需要考虑并发的问题,即防止多次被实例化,就像Spring的@Lazy注解一样。 

  1. public class Holder {  
  2.     // 默认第一次调用heavy.get()时触发的同步方法  
  3.     private Supplier<Heavy> heavy = () -> createAndCacheHeavy();   
  4.     public Holder() {  
  5.         System.out.println("Holder created");  
  6.     }  
  7.     public Heavy getHeavy() {  
  8.         // 第一次调用后heavy已经指向了新的instance,所以后续不再执行synchronized  
  9.         return heavy.get();   
  10.     } 
  11.     //...  
  12.     private synchronized Heavy createAndCacheHeavy() {  
  13.         // 方法内定义class,注意和类内的嵌套class在加载时的区别  
  14.         class HeavyFactory implements Supplier<Heavy> {  
  15.             // 饥渴初始化  
  16.             private final Heavy heavyInstance = new Heavy();   
  17.             public Heavy get() {  
  18.                 // 每次返回固定的值 
  19.                 return heavyInstance;   
  20.             }   
  21.         }       
  22.         //第一次调用方法来会将heavy重定向到新的Supplier实例  
  23.         if(!HeavyFactory.class.isInstance(heavy)) {  
  24.             heavy = new HeavyFactory();  
  25.         }  
  26.         return heavy.get();  
  27.     }  

当Holder的实例被创建时,其中的Heavy实例还没有被创建。下面我们假设有三个线程会调用getHeavy方法,其中前两个线程会同时调用,而第三个线程会在稍晚的时候调用。

当前两个线程调用该方法的时候,都会调用到createAndCacheHeavy方法,由于这个方法是同步的。因此第一个线程进入方法体,第二个线程开始等待。在方法体中会首先判断当前的heavy是否是HeavyInstance的一个实例。

如果不是,就会将heavy对象替换成HeavyFactory类型的实例。显然,第一个线程执行判断的时候,heavy对象还只是一个Supplier的实例,所以heavy会被替换成为HeavyFactory的实例,此时heavy实例会被真正的实例化。

等到第二个线程进入执行该方法时,heavy已经是HeavyFactory的一个实例了,所以会立即返回(即heavyInstance)。当第三个线程执行getHeavy方法时,由于此时的heavy对象已经是HeavyFactory的实例了,因此它会直接返回需要的实例(即heavyInstance),和同步方法createAndCacheHeavy没有任何关系了。

以上代码实际上实现了一个轻量级的虚拟代理模式(Virtual Proxy Pattern)。保证了懒加载在各种环境下的正确性。

还有一种基于delegate的实现方式更好理解一些:

https://gist.github.com/taichi/6daf50919ff276aae74f 

  1. import java.util.concurrent.ConcurrentHashMap;  
  2. import java.util.concurrent.ConcurrentMap;  
  3. import java.util.function.Supplier;  
  4. public class MemoizeSupplier<T> implements Supplier<T> {  
  5.  final Supplier<T> delegate;  
  6.  ConcurrentMap<Class>, T> map = new ConcurrentHashMap<>(1);  
  7.  public MemoizeSupplier(Supplier<T> delegate) {  
  8.   this.delegate = delegate;  
  9.  }  
  10.  @Override  
  11.  public T get() {  
  12.      // 利用computeIfAbsent方法的特性,保证只会在key不存在的时候调用一次实例化方法,进而实现单例  
  13.   return this.map.computeIfAbsent(MemoizeSupplier.class,  
  14.     k -> this.delegate.get());  
  15.  }  
  16.  public static <T> Supplier<T> of(Supplier<T> provider) {  
  17.   return new MemoizeSupplier<>(provider);  
  18.  }  

以及一个更复杂但功能更多的CloseableSupplier: 

  1. public static class CloseableSupplier<T> implements Supplier<T>, Serializable {  
  2.         private static final long serialVersionUID = 0L 
  3.         private final Supplier<T> delegate;  
  4.         private final boolean resetAfterClose; 
  5.         private volatile transient boolean initialized;  
  6.         private transient T value;  
  7.         private CloseableSupplier(Supplier<T> delegate, boolean resetAfterClose) {  
  8.             this.delegate = delegate;  
  9.             this.resetAfterClose = resetAfterClose;  
  10.         }  
  11.         public T get() {  
  12.             // 经典Singleton实现  
  13.             if (!(this.initialized)) { // 注意是volatile修饰的,保证happens-before,t一定实例化完全  
  14.                 synchronized (this) {  
  15.                     if (!(this.initialized)) { // Double Lock Check  
  16.                         T t = this.delegate.get();  
  17.                         tthis.value = t;  
  18.                         this.initialized = true 
  19.                         return t;  
  20.                     }  
  21.                 }  
  22.             }  
  23.             // 初始化后就直接读取值,不再同步抢锁  
  24.             return this.value;  
  25.         } 
  26.         public boolean isInitialized() {  
  27.             return initialized;  
  28.         }  
  29.         public <X extends Throwable> void ifPresent(ThrowableConsumer<T, X> consumer) throws X {  
  30.             synchronized (this) {  
  31.                 if (initialized && this.value != null) {  
  32.                     consumer.accept(this.value);  
  33.                 }  
  34.             }  
  35.         } 
  36.         public <U> Optional<U> map(Function super T, ? extends U> mapper) {  
  37.             checkNotNull(mapper);  
  38.             synchronized (this) {  
  39.                 if (initialized && this.value != null) {  
  40.                     return ofNullable(mapper.apply(value));  
  41.                 } else {  
  42.                     return empty();  
  43.                 }  
  44.             }  
  45.         }  
  46.         public void tryClose() {  
  47.             tryClose(i -> { });  
  48.         }  
  49.         public <X extends Throwable> void tryClose(ThrowableConsumer<T, X> close) throws X {  
  50.             synchronized (this) {  
  51.                 if (initialized) {  
  52.                     close.accept(value);  
  53.                     if (resetAfterClose) {  
  54.                         this.value = null 
  55.                         initialized = false 
  56.                     }  
  57.                 }  
  58.             }  
  59.         }  
  60.         public String toString() {  
  61.             if (initialized) {  
  62.                 return "MoreSuppliers.lazy(" + get() + ")";  
  63.             } else {  
  64.                 return "MoreSuppliers.lazy(" + this.delegate + ")";  
  65.             }  
  66.         }  
  67.     } 

Stream

Stream中的各种方法分为两类:

前者的调用并不会立即执行,只有结束方法被调用后才会依次从前往后触发整个调用链条。但是需要注意,对于集合来说,是每一个元素依次按照处理链条执行到尾,而不是每一个中间方法都将所有能处理的元素全部处理一遍才触发 下一个中间方法。比如: 

  1. List<String> names = Arrays.asList("Brad", "Kate", "Kim", "Jack", "Joe", "Mike");  
  2. final String firstNameWith3Letters = names.stream()  
  3.     .filter(name -> length(name) == 3)  
  4.     .map(name -> toUpper(name))  
  5.     .findFirst()  
  6.     .get();  
  7. System.out.println(firstNameWith3Letters); 

当触发findFirst()这一结束方法的时候才会触发整个Stream链条,每个元素依次经过filter()->map()->findFirst()后返回。所以filter()先处理第一个和第二个后不符合条件,继续处理第三个符合条件,再触发map()方法,最后将转换的结果返回给findFirst()。所以filter()触发了_3_次,map()触发了_1_次。

好,让我们来看一个实际问题,关于无限集合。

Stream类型的一个特点是:它们可以是无限的。这一点和集合类型不一样,在Java中的集合类型必须是有限的。Stream之所以可以是无限的也是源于Stream「懒」的这一特点。

Stream只会返回你需要的元素,而不会一次性地将整个无限集合返回给你。

Stream接口中有一个静态方法iterate(),这个方法能够为你创建一个无限的Stream对象。它需要接受两个参数:

public static Stream iterate(final T seed, final UnaryOperator f)

其中,seed表示的是这个无限序列的起点,而UnaryOperator则表示的是如何根据前一个元素来得到下一个元素,比如序列中的第二个元素可以这样决定:f.apply(seed)。

下面是一个计算从某个数字开始并依次返回后面count个素数的例子: 

  1. public class Primes {      
  2.     public static boolean isPrime(final int number) {  
  3.         return number > 1 &&  
  4.             // 依次从2到number的平方根判断number是否可以整除该值,即divisor  
  5.             IntStream.rangeClosed(2, (int) Math.sqrt(number))  
  6.                 .noneMatch(divisor -> number % divisor == 0);  
  7.     }   
  8.     private static int primeAfter(final int number) {  
  9.         if(isPrime(number + 1)) // 如果当前的数的下一个数是素数,则直接返回该值  
  10.             return number + 1;  
  11.         else // 否则继续从下一个数据的后面继续找到第一个素数返回,递归  
  12.             return primeAfter(number + 1);  
  13.     }  
  14.     public static List<Integer> primes(final int fromNumber, final int count) {  
  15.         return Stream.iterate(primeAfter(fromNumber - 1), Primes::primeAfter)  
  16.             .limit(count)  
  17.             .collect(Collectors.<Integer>toList());  
  18.     }  
  19.     //...  

对于iterate和limit,它们只是中间操作,得到的对象仍然是Stream类型。对于collect方法,它是一个结束操作,会触发中间操作来得到需要的结果。

如果用非Stream的方式需要面临两个问题:

即不知道第一个素数的位置在哪儿,需要提前计算出来第一个素数,然后用while来处理count次查找后续的素数。可能primes方法的实现会拆成两部分,实现复杂。如果用Stream来实现,流式的处理,无限迭代,指定截止条件,内部的一套机制可以保证实现和执行都很优雅。 

 

来源:Java知音内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯