添加Lambda表达式实现原理

Author: CarpenterLee

2-Labmda and Anonymous Classes(II).md

@@ -0,0 +1,96 @@
+# Labmda and Anonymous Classes(II)
+
+# 前言
+
+读过上一篇之后，相信对Lambda表达式的语法以及基本原理有了一定了解。对于编写代码，有这些知识已经够用。本文将**进一步区分Lambda表达式和匿名内部类在JVM层面的区别，如果对这一部分不感兴趣，可以跳过**。
+
+# 不仅是匿名内部类的简写
+
+经过第一篇的的介绍，我们看到Lambda表达式似乎只是为了简化匿名内部类书写，这看起来仅仅通过语法糖在编译阶段把所有的Lambda表达式替换成匿名内部类就可以了。但实时并非如此。在JVM层面，Lambda表达式和匿名内部类有着明显的差别。
+
+## 匿名内部类实现
+
+**匿名内部类仍然是一个类，只是不需要程序员显示指定类名，编译器会自动为该类取名**。因此如果有如下形式的代码，编译之后将会产生两个class文件：
+
+```java
+public class MainAnonymousClass {
+	public static void main(String[] args) {
+		new Thread(new Runnable(){
+			@Override
+			public void run(){
+				System.out.println("Anonymous Class Thread run()");
+			}
+		}).start();;
+	}
+}
+```
+编译之后文件分布如下，两个class文件分别是主类和匿名内部类产生的：
+
+![2-AnonymousClass.png](./Figures/2-AnonymousClass.png)
+
+进一步分析主类MainAnonymousClass.class的字节码，可发现其创建了匿名内部类的对象：
+
+```java
+// javap -c MainAnonymousClass.class
+public class MainAnonymousClass {
+  ...
+  public static void main(java.lang.String[]);
+    Code:
+       0: new           #2                  // class java/lang/Thread
+       3: dup
+       4: new           #3                  // class MainAnonymousClass$1 /*创建内部类对象*/
+       7: dup
+       8: invokespecial #4                  // Method MainAnonymousClass$1."<init>":()V
+      11: invokespecial #5                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
+      14: invokevirtual #6                  // Method java/lang/Thread.start:()V
+      17: return
+}
+
+```
+## Lambda表达式实现
+
+**Lambda表达式通过*invokedynamic*指令实现，书写Lambda表达式不会产生新的类**。如果有如下代码，编译之后只有一个class文件：
+
+```java
+public class MainLambda {
+	public static void main(String[] args) {
+		new Thread(
+				() -> System.out.println("Lambda Thread run()")
+			).start();;
+	}
+}
+```
+编译之后的结果：
+
+![2-Lambda](./Figures/2-Lambda.png)
+
+通过javap反编译命名，我们更能看出Lambda表达式内部表示的不同：
+
+```java
+// javap -c -p MainLambda.class
+public class MainLambda {
+  ...
+  public static void main(java.lang.String[]);
+    Code:
+       0: new           #2                  // class java/lang/Thread
+       3: dup
+       4: invokedynamic #3,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable; /*使用invokedynamic指令调用*/
+       9: invokespecial #4                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
+      12: invokevirtual #5                  // Method java/lang/Thread.start:()V
+      15: return
+
+  private static void lambda$main$0();  /*Lambda表达式变成了主类的私有方法*/
+    Code:
+       0: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
+       3: ldc           #7                  // String Lambda Thread run()
+       5: invokevirtual #8                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
+       8: return
+}
+
+```
+
+反编译之后我们发现Lambda表达式被封装成了主类的一个私有方法，并通过*invokedynamic*指令进行调用。
+
+
+
+

Figures/2-AnonymousClass.png

@@ -20,8 +20,8 @@ Java 8已经发行两年多，但很多人仍然在使用JDK7。对企业来说
 
 具体内容安排如下：
 
-1. Labmda and Anonymous Classes(I)，展示如何使用Lambda表达式替代匿名内部类
-2. Labmda and Anonymous Classes(II)，Lambda表达式的实现原理
+1. [Labmda and Anonymous Classes(I)](./1-Labmda and Anonymous Classes(I).md)，展示如何使用Lambda表达式替代匿名内部类
+2. [Labmda and Anonymous Classes(II)](./2-Labmda and Anonymous Classes(II).md)，Lambda表达式的实现原理
 3. Lambda and Stream，展示Lambda表达式如何跟Stream配合使用
 4. Functional interfaces，展示函数接口的作用，和常见函数接口
 4. Stream API的使用，详细讲解Stream API的用法