Java延遲初始化簡單介紹

這篇文章主要講解了“Java延遲初始化簡單介紹”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Java延遲初始化簡單介紹”吧！

延遲初始化

一般有幾種延遲初始化的場景：

•  對于會消耗較多資源的對象：這不僅能夠節省一些資源，同時也能夠加快對象的創建速度，從而從整體上提升性能。

•  某些數據在啟動時無法獲取：比如一些上下文信息可能在其他攔截器或處理中才能被設置，導致當前bean在加載的時候可能獲取不到對應的變量的值，使用 延遲初始化可以在真正調用的時候去獲取，通過延遲來保證數據的有效性。

在Java8中引入的lambda對于我們實現延遲操作提供很大的便捷性，如Stream、Supplier等，下面介紹幾個例子。

Lambda

Supplier

通過調用get()方法來實現具體對象的計算和生成并返回，而不是在定義Supplier的時候計算，從而達到了_延遲初始化_的目的。但是在使用 中往往需要考慮并發的問題，即防止多次被實例化，就像Spring的@Lazy注解一樣。

public class Holder {      // 默認第一次調用heavy.get()時觸發的同步方法      private Supplier<Heavy> heavy = () -> createAndCacheHeavy();       public Holder() {          System.out.println("Holder created");      }      public Heavy getHeavy() {          // 第一次調用后heavy已經指向了新的instance，所以后續不再執行synchronized          return heavy.get();       }     //...      private synchronized Heavy createAndCacheHeavy() {          // 方法內定義class，注意和類內的嵌套class在加載時的區別          class HeavyFactory implements Supplier<Heavy> {              // 饑渴初始化              private final Heavy heavyInstance = new Heavy();               public Heavy get() {                  // 每次返回固定的值                 return heavyInstance;               }           }               //第一次調用方法來會將heavy重定向到新的Supplier實例          if(!HeavyFactory.class.isInstance(heavy)) {              heavy = new HeavyFactory();          }          return heavy.get();      }  }

當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

import java.util.concurrent.ConcurrentHashMap;  import java.util.concurrent.ConcurrentMap;  import java.util.function.Supplier;  public class MemoizeSupplier<T> implements Supplier<T> {   final Supplier<T> delegate;   ConcurrentMap<Class<?>, T> map = new ConcurrentHashMap<>(1);   public MemoizeSupplier(Supplier<T> delegate) {    this.delegate = delegate;   }   @Override   public T get() {       // 利用computeIfAbsent方法的特性，保證只會在key不存在的時候調用一次實例化方法，進而實現單例    return this.map.computeIfAbsent(MemoizeSupplier.class,      k -> this.delegate.get());   }   public static <T> Supplier<T> of(Supplier<T> provider) {    return new MemoizeSupplier<>(provider);   }  }

以及一個更復雜但功能更多的CloseableSupplier：

public static class CloseableSupplier<T> implements Supplier<T>, Serializable {          private static final long serialVersionUID = 0L;          private final Supplier<T> delegate;          private final boolean resetAfterClose;         private volatile transient boolean initialized;          private transient T value;          private CloseableSupplier(Supplier<T> delegate, boolean resetAfterClose) {              this.delegate = delegate;              this.resetAfterClose = resetAfterClose;          }          public T get() {              // 經典Singleton實現              if (!(this.initialized)) { // 注意是volatile修飾的，保證happens-before，t一定實例化完全                  synchronized (this) {                      if (!(this.initialized)) { // Double Lock Check                          T t = this.delegate.get();                          tthis.value = t;                          this.initialized = true;                          return t;                      }                  }              }              // 初始化后就直接讀取值，不再同步搶鎖              return this.value;          }         public boolean isInitialized() {              return initialized;          }          public <X extends Throwable> void ifPresent(ThrowableConsumer<T, X> consumer) throws X {              synchronized (this) {                  if (initialized && this.value != null) {                      consumer.accept(this.value);                  }              }          }         public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {              checkNotNull(mapper);              synchronized (this) {                  if (initialized && this.value != null) {                      return ofNullable(mapper.apply(value));                  } else {                      return empty();                  }              }          }          public void tryClose() {              tryClose(i -> { });          }          public <X extends Throwable> void tryClose(ThrowableConsumer<T, X> close) throws X {              synchronized (this) {                  if (initialized) {                      close.accept(value);                      if (resetAfterClose) {                          this.value = null;                          initialized = false;                      }                  }              }          }          public String toString() {              if (initialized) {                  return "MoreSuppliers.lazy(" + get() + ")";              } else {                  return "MoreSuppliers.lazy(" + this.delegate + ")";              }          }      }

Stream

Stream中的各種方法分為兩類：

•  中間方法(limit()/iterate()/filter()/map())

•  結束方法(collect()/findFirst()/findAny()/count())

前者的調用并不會立即執行，只有結束方法被調用后才會依次從前往后觸發整個調用鏈條。但是需要注意，對于集合來說，是每一個元素依次按照處理鏈條執行到尾，而不是每一個中間方法都將所有能處理的元素全部處理一遍才觸發 下一個中間方法。比如：

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

當觸發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個素數的例子：

public class Primes {          public static boolean isPrime(final int number) {          return number > 1 &&              // 依次從2到number的平方根判斷number是否可以整除該值，即divisor              IntStream.rangeClosed(2, (int) Math.sqrt(number))                  .noneMatch(divisor -> number % divisor == 0);      }       private static int primeAfter(final int number) {          if(isPrime(number + 1)) // 如果當前的數的下一個數是素數，則直接返回該值              return number + 1;          else // 否則繼續從下一個數據的后面繼續找到第一個素數返回，遞歸              return primeAfter(number + 1);      }      public static List<Integer> primes(final int fromNumber, final int count) {          return Stream.iterate(primeAfter(fromNumber - 1), Primes::primeAfter)              .limit(count)              .collect(Collectors.<Integer>toList());      }      //...  }

對于iterate和limit，它們只是中間操作，得到的對象仍然是Stream類型。對于collect方法，它是一個結束操作，會觸發中間操作來得到需要的結果。

如果用非Stream的方式需要面臨兩個問題：

•  一是無法提前知曉fromNumber后count個素數的數值邊界是什么

•  二是無法使用有限的集合來表示計算范圍，無法計算超大的數值

即不知道第一個素數的位置在哪兒，需要提前計算出來第一個素數，然后用while來處理count次查找后續的素數。可能primes方法的實現會拆成兩部分，實現復雜。如果用Stream來實現，流式的處理，無限迭代，指定截止條件，內部的一套機制可以保證實現和執行都很優雅。

感謝各位的閱讀，以上就是“Java延遲初始化簡單介紹”的內容了，經過本文的學習后，相信大家對Java延遲初始化簡單介紹這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！