摘要：本文已收錄修煉內功躍遷之路初次接觸的時候感覺表達式很神奇表達式帶來的編程新思路，但又總感覺它就是匿名類或者內部類的語法糖而已，只是語法上更為簡潔罷了，如同以下的代碼匿名類內部類編譯后會產生三個文件雖然從使用效果來看，與匿名類或者內部類有相

本文已收錄【修煉內功】躍遷之路

初次接觸Java8的時候感覺Lambda表達式很神奇(Lambda表達式帶來的編程新思路)，但又總感覺它就是匿名類或者內部類的語法糖而已，只是語法上更為簡潔罷了，如同以下的代碼

public class Lambda {
    private static void hello(String name, Consumer printer) {
        printer.accept(name);
    }

    public static void main(String[] args) {
        hello("lambda", (name) -> System.out.println("Hello " + name));
        hello("匿名類", new Consumer () {
            @Override
            public void accept(String name) {
                System.out.println("Hello " + name);
            }
        });
        hello("內部類", new SupplierImpl());
    }

    static class SupplierImpl implements Consumer {
        @Override
        public void accept(String name) {
            System.out.println("Hello " + name);
        }
    }
}

編譯后會產生三個文件

雖然從使用效果來看，Lambda與匿名類或者內部類有相似之處(當然也有很大不同，如this指針等 Lambda表達式里的"陷阱")，但從編譯結果來看，并不能簡單地將Lambda與匿名類/內部類劃等號

簡單查看Lambda字節碼javap -p Lambda

Java編譯器自動幫我們生成了方法lambda$main$0，我們有理由相信，Lambda表達式內的邏輯就封裝在此函數內

生成的方法lambda$main$0又是如何被調用的呢？

Lambda的調用使用了invokedynamic指令，虛擬機視角的方法調用一文中已經詳細介紹了invokedynamic，但這里還是看不出invokedynamic指令與lambda$main$0方法之間到底是如何關聯起來的，invokedynamic指令的啟動函數(BootstrapMethod)與調用點(CallSite)又在哪里？

其實仔細查看字節碼的話可以發下，編譯器還會額外生成一個內部類

仔細查看內部類的邏輯，是不是像極了虛擬機視角的方法調用一文中所提invokedynamic的運行過程

在第一次執行invokedynamic時，JVM虛擬機會調用該指令所對應的啟動方法(BootstrapMethod)來生成調用點
啟動方法(BootstrapMethod)由方法句柄來指定(MH_BootstrapMethod)
啟動方法接受三個固定的參數，分別為 Lookup實例、指代目標方法名的字符串及該調用點能夠鏈接的方法句柄類型
將調用點綁定至該invokedynamic指令中，之后的運行中虛擬機會直接調用綁定的調用點所鏈接的方法句柄

為了驗證此想法，可以執行java -Djdk.internal.lambda.dumpProxyClasses Lambda用來導出內部類

跟蹤內部類的運行可以發現，在執行lambda表達式的時候會調用MethodHandleNatives.linkCallSite方法來生成并鏈接到調用點

// Up-calls from the JVM.
// These must NOT be public.

/**
  * The JVM is linking an invokedynamic instruction.  Create a reified call site for it.
  */
static MemberName linkCallSite(Object callerObj,
                               Object bootstrapMethodObj,
                               Object nameObj, Object typeObj,
                               Object staticArguments,
                               Object[] appendixResult) {
    MethodHandle bootstrapMethod = (MethodHandle)bootstrapMethodObj;
    Class caller = (Class)callerObj;
    String name = nameObj.toString().intern();
    MethodType type = (MethodType)typeObj;
    if (!TRACE_METHOD_LINKAGE)
        return linkCallSiteImpl(caller, bootstrapMethod, name, type,
                                staticArguments, appendixResult);
    return linkCallSiteTracing(caller, bootstrapMethod, name, type,
                               staticArguments, appendixResult);
}
static MemberName linkCallSiteImpl(Class caller,
                                   MethodHandle bootstrapMethod,
                                   String name, MethodType type,
                                   Object staticArguments,
                                   Object[] appendixResult) {
    CallSite callSite = CallSite.makeSite(bootstrapMethod,
                                          name,
                                          type,
                                          staticArguments,
                                          caller);
    if (callSite instanceof ConstantCallSite) {
        appendixResult[0] = callSite.dynamicInvoker();
        return Invokers.linkToTargetMethod(type);
    } else {
        appendixResult[0] = callSite;
        return Invokers.linkToCallSiteMethod(type);
    }
}

caller為調用lambda方法的類Lambda [Class]

bootstrapMethod為啟動方法的句柄 [MethodHandler]

name為lambda表達式實際類型中需要執行的方法名acccept (Consumer.accept)

type為生成的方法類型()Consumer [MethodType]

staticArguments中包含了lambda方法的方法句柄 [MethodHandler] 及方法類型 [MethodType]

CallSite.makeSite方法會生成調用點，最終調用如class文件中所示的LambdaMetafactory.metafactory方法

public static CallSite metafactory(MethodHandles.Lookup caller,
                                   String invokedName,
                                   MethodType invokedType,
                                   MethodType samMethodType,
                                   MethodHandle implMethod,
                                   MethodType instantiatedMethodType)
    throws LambdaConversionException {
    AbstractValidatingLambdaMetafactory mf;
    mf = new InnerClassLambdaMetafactory(caller, invokedType,
                                         invokedName, samMethodType,
                                         implMethod, instantiatedMethodType,
                                         false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY);
    mf.validateMetafactoryArgs();
    return mf.buildCallSite();
}

簡單來講，所生成內部類作用，是為了生成調用點，并鏈接到invokedynamic指令，以便動態調用

如果一個類中，多次使用lambda表達式，會生成多少個方法，又會生成多少個內部類？

public class Lambda {
    private static void hello(String name, Consumer printer) {
        printer.accept(name);
    }

    public static void main(String[] args) {
        hello("lambda1", (name) -> System.out.println("Hello " + name));
        hello("lambda2", (name) -> System.out.println("Hello " + name));
        new Thread(() -> {
            System.out.println("thread");
        }).start();
    }
}

上述示例中共使用了三處、兩種(Consumer、Runnable)Lambda表達式，編譯后查看class文件

對于每一個lambda表達式，都會生成一個靜態的私有方法

再查看內部類

只會生成一個內部類，但存在三個方法，每個方法對應一個lambda私有方法，用以生成對應的調用點綁定到相應的invokedynamic指令上

結合以上我們可以總結出：

lambda表達式會被編譯為invokedynamic指令

每一個lambda表達式的實現邏輯均會被封裝為一個靜態私有方法

只要存在lambda表達式調用，便會生成一個內部類

內部類中每一個方法（啟動方法 BoostrapMethod）對應一個lambda表達式所生成的靜態私有方法，內部類中的方法用以生成對應的調用點綁定到相應的invokedynamic指令上

這也解釋了為什么lambda中的this指針指向的是周圍的類 (定義該Lambda表達式時所處的類) (Lambda表達式里的"陷阱")

所以，lambda表達式確實是語法糖，但并不是匿名類/內部類的語法糖