日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
Java關(guān)于延遲加載的一些應用實踐

 代碼中的很多操作都是Eager的，比如在發(fā)生方法調(diào)用的時候，參數(shù)會立即被求值?？傮w而言，使用Eager方式讓編碼本身更加簡單，然而使用Lazy的方式通常而言，即意味著更好的效率。

讓客戶滿意是我們工作的目標，不斷超越客戶的期望值來自于我們對這個行業(yè)的熱愛。我們立志把好的技術(shù)通過有效、簡單的方式提供給客戶，將通過不懈努力成為客戶在信息化領(lǐng)域值得信任、有價值的長期合作伙伴，公司提供的服務項目有：空間域名、網(wǎng)頁空間、營銷軟件、網(wǎng)站建設、湛河網(wǎng)站維護、網(wǎng)站推廣。

延遲初始化

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

  •  對于會消耗較多資源的對象：這不僅能夠節(jié)省一些資源，同時也能夠加快對象的創(chuàng)建速度，從而從整體上提升性能。
  •  某些數(shù)據(jù)在啟動時無法獲取：比如一些上下文信息可能在其他攔截器或處理中才能被設置，導致當前bean在加載的時候可能獲取不到對應的變量的值，使用 延遲初始化可以在真正調(diào)用的時候去獲取，通過延遲來保證數(shù)據(jù)的有效性。

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

Lambda

Supplier

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

 
 
 
    
  
  
  
  1. public class Holder {  
    2. 
  
  
  
  2.     // 默認第一次調(diào)用heavy.get()時觸發(fā)的同步方法  
    3. 
  
  
  
  3.     private Supplier heavy = () -> createAndCacheHeavy();   
    4. 
  
  
  
  4.     public Holder() {  
    5. 
  
  
  
  5.         System.out.println("Holder created");  
    6. 
  
  
  
  6.     }  
    7. 
  
  
  
  7.     public Heavy getHeavy() {  
    8. 
  
  
  
  8.         // 第一次調(diào)用后heavy已經(jīng)指向了新的instance，所以后續(xù)不再執(zhí)行synchronized  
    9. 
  
  
  
  9.         return heavy.get();   
    10. 
  
  
  
  10.     } 
    11. 
  
  
  
  11.     //...  
    12. 
  
  
  
  12.     private synchronized Heavy createAndCacheHeavy() {  
    13. 
  
  
  
  13.         // 方法內(nèi)定義class，注意和類內(nèi)的嵌套class在加載時的區(qū)別  
    14. 
  
  
  
  14.         class HeavyFactory implements Supplier {  
    15. 
  
  
  
  15.             // 饑渴初始化  
    16. 
  
  
  
  16.             private final Heavy heavyInstance = new Heavy();   
    17. 
  
  
  
  17.             public Heavy get() {  
    18. 
  
  
  
  18.                 // 每次返回固定的值 
    19. 
  
  
  
  19.                 return heavyInstance;   
    20. 
  
  
  
  20.             }   
    21. 
  
  
  
  21.         }       
    22. 
  
  
  
  22.         //第一次調(diào)用方法來會將heavy重定向到新的Supplier實例  
    23. 
  
  
  
  23.         if(!HeavyFactory.class.isInstance(heavy)) {  
    24. 
  
  
  
  24.             heavy = new HeavyFactory();  
    25. 
  
  
  
  25.         }  
    26. 
  
  
  
  26.         return heavy.get();  
    27. 
  
  
  
  27.     }  
    28. 
  
  
  
  28. } 
    29.

當Holder的實例被創(chuàng)建時，其中的Heavy實例還沒有被創(chuàng)建。下面我們假設有三個線程會調(diào)用getHeavy方法，其中前兩個線程會同時調(diào)用，而第三個線程會在稍晚的時候調(diào)用。

當前兩個線程調(diào)用該方法的時候，都會調(diào)用到createAndCacheHeavy方法，由于這個方法是同步的。因此第一個線程進入方法體，第二個線程開始等待。在方法體中會首先判斷當前的heavy是否是HeavyInstance的一個實例。

如果不是，就會將heavy對象替換成HeavyFactory類型的實例。顯然，第一個線程執(zhí)行判斷的時候，heavy對象還只是一個Supplier的實例，所以heavy會被替換成為HeavyFactory的實例，此時heavy實例會被真正的實例化。

等到第二個線程進入執(zhí)行該方法時，heavy已經(jīng)是HeavyFactory的一個實例了，所以會立即返回（即heavyInstance）。當?shù)谌齻€線程執(zhí)行g(shù)etHeavy方法時，由于此時的heavy對象已經(jīng)是HeavyFactory的實例了，因此它會直接返回需要的實例（即heavyInstance），和同步方法createAndCacheHeavy沒有任何關(guān)系了。

以上代碼實際上實現(xiàn)了一個輕量級的虛擬代理模式(Virtual Proxy Pattern)。保證了懶加載在各種環(huán)境下的正確性。

還有一種基于delegate的實現(xiàn)方式更好理解一些：

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

 
 
 
    
  
  
  
  1. import java.util.concurrent.ConcurrentHashMap;  
    2. 
  
  
  
  2. import java.util.concurrent.ConcurrentMap;  
    3. 
  
  
  
  3. import java.util.function.Supplier;  
    4. 
  
  
  
  4. public class MemoizeSupplier implements Supplier {  
    5. 
  
  
  
  5.  final Supplier delegate;  
    6. 
  
  
  
  6.  ConcurrentMap, T> map = new ConcurrentHashMap<>(1);  
    7. 
  
  
  
  7.  public MemoizeSupplier(Supplier delegate) {  
    8. 
  
  
  
  8.   this.delegate = delegate;  
    9. 
  
  
  
  9.  }  
    10. 
  
  
  
  10.  @Override  
    11. 
  
  
  
  11.  public T get() {  
    12. 
  
  
  
  12.      // 利用computeIfAbsent方法的特性，保證只會在key不存在的時候調(diào)用一次實例化方法，進而實現(xiàn)單例  
    13. 
  
  
  
  13.   return this.map.computeIfAbsent(MemoizeSupplier.class,  
    14. 
  
  
  
  14.     k -> this.delegate.get());  
    15. 
  
  
  
  15.  }  
    16. 
  
  
  
  16.  public static  Supplier of(Supplier provider) {  
    17. 
  
  
  
  17.   return new MemoizeSupplier<>(provider);  
    18. 
  
  
  
  18.  }  
    19. 
  
  
  
  19. } 
    20.

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

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

Stream

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

  •  中間方法(limit()/iterate()/filter()/map())
  •  結(jié)束方法(collect()/findFirst()/findAny()/count())

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

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

當觸發(fā)findFirst()這一結(jié)束方法的時候才會觸發(fā)整個Stream鏈條，每個元素依次經(jīng)過filter()->map()->findFirst()后返回。所以filter()先處理第一個和第二個后不符合條件，繼續(xù)處理第三個符合條件，再觸發(fā)map()方法，最后將轉(zhuǎn)換的結(jié)果返回給findFirst()。所以filter()觸發(fā)了_3_次，map()觸發(fā)了_1_次。

好，讓我們來看一個實際問題，關(guān)于無限集合。

Stream類型的一個特點是：它們可以是無限的。這一點和集合類型不一樣，在Java中的集合類型必須是有限的。Stream之所以可以是無限的也是源于Stream「懶」的這一特點。

Stream只會返回你需要的元素，而不會一次性地將整個無限集合返回給你。

Stream接口中有一個靜態(tài)方法iterate()，這個方法能夠為你創(chuàng)建一個無限的Stream對象。它需要接受兩個參數(shù)：

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

其中，seed表示的是這個無限序列的起點，而UnaryOperator則表示的是如何根據(jù)前一個元素來得到下一個元素，比如序列中的第二個元素可以這樣決定：f.apply(seed)。

下面是一個計算從某個數(shù)字開始并依次返回后面count個素數(shù)的例子： 

 
 
 
    
  
  
  
  1. public class Primes {      
    2. 
  
  
  
  2.     public static boolean isPrime(final int number) {  
    3. 
  
  
  
  3.         return number > 1 &&  
    4. 
  
  
  
  4.             // 依次從2到number的平方根判斷number是否可以整除該值，即divisor  
    5. 
  
  
  
  5.             IntStream.rangeClosed(2, (int) Math.sqrt(number))  
    6. 
  
  
  
  6.                 .noneMatch(divisor -> number % divisor == 0);  
    7. 
  
  
  
  7.     }   
    8. 
  
  
  
  8.     private static int primeAfter(final int number) {  
    9. 
  
  
  
  9.         if(isPrime(number + 1)) // 如果當前的數(shù)的下一個數(shù)是素數(shù)，則直接返回該值  
    10. 
  
  
  
  10.             return number + 1;  
    11. 
  
  
  
  11.         else // 否則繼續(xù)從下一個數(shù)據(jù)的后面繼續(xù)找到第一個素數(shù)返回，遞歸  
    12. 
  
  
  
  12.             return primeAfter(number + 1);  
    13. 
  
  
  
  13.     }  
    14. 
  
  
  
  14.     public static List primes(final int fromNumber, final int count) {  
    15. 
  
  
  
  15.         return Stream.iterate(primeAfter(fromNumber - 1), Primes::primeAfter)  
    16. 
  
  
  
  16.             .limit(count)  
    17. 
  
  
  
  17.             .collect(Collectors.toList());  
    18. 
  
  
  
  18.     }  
    19. 
  
  
  
  19.     //...  
    20. 
  
  
  
  20. } 
    21.

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

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

  •  一是無法提前知曉fromNumber后count個素數(shù)的數(shù)值邊界是什么
  •  二是無法使用有限的集合來表示計算范圍，無法計算超大的數(shù)值

即不知道第一個素數(shù)的位置在哪兒，需要提前計算出來第一個素數(shù)，然后用while來處理count次查找后續(xù)的素數(shù)?？赡躳rimes方法的實現(xiàn)會拆成兩部分，實現(xiàn)復雜。如果用Stream來實現(xiàn)，流式的處理，無限迭代，指定截止條件，內(nèi)部的一套機制可以保證實現(xiàn)和執(zhí)行都很優(yōu)雅。


網(wǎng)頁標題：Java關(guān)于延遲加載的一些應用實踐
URL地址：http://m.5511xx.com/article/cogoocd.html