[[381098]]

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

延遲初始化

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

•  對于會消耗較多資源的對象：這不僅能夠節(jié)省一些資源，同時也能夠加快對象的創(chuàng)建速度，從而從整體上提升性能。
•  某些數(shù)據(jù)在啟動時無法獲?。罕热缫恍┥舷挛男畔⒖赡茉谄渌麛r截器或處理中才能被設(shè)置，導(dǎo)致當(dāng)前bean在加載的時候可能獲取不到對應(yīng)的變量的值，使用 延遲初始化可以在真正調(diào)用的時候去獲取，通過延遲來保證數(shù)據(jù)的有效性。

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

Lambda

Supplier

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

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

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

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

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

等到第二個線程進(jìn)入執(zhí)行該方法時，heavy已經(jīng)是HeavyFactory的一個實例了，所以會立即返回（即heavyInstance）。當(dāng)?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 

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不存在的時候調(diào)用一次實例化方法，進(jìn)而實現(xiàn)單例  
  return this.map.computeIfAbsent(MemoizeSupplier.class,  
    k -> this.delegate.get());  
 }  
 public static <T> Supplier<T> of(Supplier<T> provider) {  
  return new MemoizeSupplier<>(provider);  
 }  
} 

以及一個更復(fù)雜但功能更多的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() {  
            // 經(jīng)典Singleton實現(xiàn)  
            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())
•  結(jié)束方法(collect()/findFirst()/findAny()/count())

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

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

當(dāng)觸發(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ù)的例子： 

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)) // 如果當(dāng)前的數(shù)的下一個數(shù)是素數(shù)，則直接返回該值  
            return number + 1;  
        else // 否則繼續(xù)從下一個數(shù)據(jù)的后面繼續(xù)找到第一個素數(shù)返回，遞歸  
            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方法，它是一個結(jié)束操作，會觸發(fā)中間操作來得到需要的結(jié)果。

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

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

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