2. 程式人生 > >Java8 Lambda表示式原理掃盲

Java8 Lambda表示式原理掃盲

阿新 • • 發佈：2018-11-20

背景

在使用Lamdba表示式，一直以為是內部類的方式實現的，但是一想如果每次呼叫都例項化一個內部類，效能肯定不好，難道Java裡的lambda表示式真的是這麼實現的嗎？也許是該研究下原理了。

正文

  1. 測試程式碼：
public class Test{
    public void test() {
        Runnable r = () -> System.out.println(123);
        r.run();
    }
}

執行編譯命令javac -g Test.java，得到class檔案。

  1. 檢視位元組碼

檢視位元組碼javap -p -verbose Test

得到：

Classfile /Users/liushijie/learn/Test.class
  Last modified Nov 20, 2018; size 1058 bytes
  MD5 checksum febbe61fdc1f4564d2e039067752d6fc
  Compiled from "Test.java"
public class Test
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #7.#21         // java/lang/Object."<init>":()V
   #2 = InvokeDynamic      #0:#26         // #0:run:()Ljava/lang/Runnable;
   #3 = InterfaceMethodref #27.#28        // java/lang/Runnable.run:()V
   #4 = Fieldref           #29.#30        // java/lang/System.out:Ljava/io/PrintStream;
   #5 = Methodref          #31.#32        // java/io/PrintStream.println:(I)V
   #6 = Class              #33            // Test
   #7 = Class              #34            // java/lang/Object
   #8 = Utf8               <init>
   #9 = Utf8               ()V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               LocalVariableTable
  #13 = Utf8               this
  #14 = Utf8               LTest;
  #15 = Utf8               test
  #16 = Utf8               r
  #17 = Utf8               Ljava/lang/Runnable;
  #18 = Utf8               lambda$test$0
  #19 = Utf8               SourceFile
  #20 = Utf8               Test.java
  #21 = NameAndType        #8:#9          // "<init>":()V
  #22 = Utf8               BootstrapMethods
  #23 = MethodHandle       #6:#35         // invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
  #24 = MethodType         #9             //  ()V
  #25 = MethodHandle       #6:#36         // invokestatic Test.lambda$test$0:()V
  #26 = NameAndType        #37:#38        // run:()Ljava/lang/Runnable;
  #27 = Class              #39            // java/lang/Runnable
  #28 = NameAndType        #37:#9         // run:()V
  #29 = Class              #40            // java/lang/System
  #30 = NameAndType        #41:#42        // out:Ljava/io/PrintStream;
  #31 = Class              #43            // java/io/PrintStream
  #32 = NameAndType        #44:#45        // println:(I)V
  #33 = Utf8               Test
  #34 = Utf8               java/lang/Object
  #35 = Methodref          #46.#47        // java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
  #36 = Methodref          #6.#48         // Test.lambda$test$0:()V
  #37 = Utf8               run
  #38 = Utf8               ()Ljava/lang/Runnable;
  #39 = Utf8               java/lang/Runnable
  #40 = Utf8               java/lang/System
  #41 = Utf8               out
  #42 = Utf8               Ljava/io/PrintStream;
  #43 = Utf8               java/io/PrintStream
  #44 = Utf8               println
  #45 = Utf8               (I)V
  #46 = Class              #49            // java/lang/invoke/LambdaMetafactory
  #47 = NameAndType        #50:#54        // metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
  #48 = NameAndType        #18:#9         // lambda$test$0:()V
  #49 = Utf8               java/lang/invoke/LambdaMetafactory
  #50 = Utf8               metafactory
  #51 = Class              #56            // java/lang/invoke/MethodHandles$Lookup
  #52 = Utf8               Lookup
  #53 = Utf8               InnerClasses
  #54 = Utf8               (Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
  #55 = Class              #57            // java/lang/invoke/MethodHandles
  #56 = Utf8               java/lang/invoke/MethodHandles$Lookup
  #57 = Utf8               java/lang/invoke/MethodHandles
{
  public Test();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 1: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   LTest;

  public void test();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=2, args_size=1
         0: invokedynamic #2,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable;
         5: astore_1
         6: aload_1
         7: invokeinterface #3,  1            // InterfaceMethod java/lang/Runnable.run:()V
        12: return
      LineNumberTable:
        line 3: 0
        line 4: 6
        line 5: 12
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      13     0  this   LTest;
            6       7     1     r   Ljava/lang/Runnable;

  private static void lambda$test$0();
    descriptor: ()V
    flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: bipush        123
         5: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
         8: return
      LineNumberTable:
        line 3: 0
}
SourceFile: "Test.java"
InnerClasses:
     public static final #52= #51 of #55; //Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles
BootstrapMethods:
  0: #23 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
    Method arguments:
      #24 ()V
      #25 invokestatic Test.lambda$test$0:()V
      #24 ()V

通過位元組碼檔案我們可以看到，編譯出來的位元組碼檔案中新增一些玩意：

  1. 常量池裡（#2）多了一個以前沒有見過的InvokeDynamic指令
  2. 新增了一個靜態私有方法：private static void lambda$test$0()，裡面的內容正好是lambda表示式裡的程式碼；
  3. 新增了一個BootstrapMethods屬性，內部包含一個動態呼叫點列表，因為測試程式碼只有一個lambda表示式，所以我們只能看到一個呼叫點

在執行時有一個連結(link)過程，在JVM層面呼叫。通過連結操作，呼叫上面3中的呼叫點，呼叫點在動態生成實現了FunctionInterface介面的類，方法中則呼叫2中新增的lambda$test$0方法，生成類之後通過建構函式例項化一個物件，被呼叫點持有，呼叫點有一個字的常量池。在呼叫invokedynamic

指令之前會發生連結過程。下文引自：參考5
裡面也有提到過多執行緒場景，略過不提。

Before the JVM can execute a dynamic call site (an invokedynamic instruction), the call site must first be linked. Linking is accomplished by calling a bootstrap method which is given the static information content of the call site, and which must produce a method handle that gives the behavior of the call site.

總結

通過一些驗證和資料檢索，大概瞭解lambda的原理，是使用指令與動態生成的內部類來完成呼叫，而且正常只會被連結一次。從這個點上來看，對效能是沒有什麼損失的，可以放心的使用。

問題

自己梳理的比較膚淺，沒有深挖最底層的實現。LambdaMetafactory.metafactory動態呼叫點的連結過程比較長，如果有動態呼叫的場景應該是可以參考的。翻到過一篇問答（見參考6），暫時沒找到合適的場景使用，沒有深入下去的動力。

參考

  1. Lambda表示式實現方式
  2. InvokeDynamic指令JSR 292
  3. https://stackoverflow.com/questions/26775676/explicit-use-of-lambdametafactory
  4. https://zhuanlan.zhihu.com/p/27159693
  5. https://docs.oracle.com/javase/8/docs/api/java/lang/invoke/package-summary.html#package.description
  6. https://stackoverflow.com/questions/26775676/explicit-use-of-lambdametafactory

相關推薦

Java8 Lambda表示式原理掃盲

背景 在使用Lamdba表示式，一直以為是內部類的方式實現的，但是一想如果每次呼叫都例項化一個內部類，效能肯定不好，難道Java裡的lambda表示式真的是這麼實現的嗎？也許是該研究下原理了。 正文 測試程式碼： public class Test{ public void test

jdk8 lambda表示式總結 Java8 lambda表示式10個示例

Java8 lambda表示式10個示例   　1. 實現Runnable執行緒案例 使用() -> {} 替代匿名類： //Before Java 8: new Thread(new Runnable() { @Override

Java8——Lambda表示式入門

之前一直有聽說過Lambda表示式，但是一直也沒有使用過，最近學習了一下，感覺還不錯，簡單方便，把原來需要很多行才能實現的功能可以直接一行實現。不過最好也不要盲目的使用，並不是所有情況都適合用它！ 引用一段大佬的話——超過3行的邏輯就不適用Lambda表示式了。雖然看著很先進，其實Lambd

Java Builder模式 Lambda表示式 Java8 lambda表示式10個示例

Java Builder模式 package com.cathay;/** * @Description * @TODO * @Author [email protected] * @Date 建立時間：2018/11/16 **/public class Person { private

java8--lambda表示式

java8中lambda表示式，類似c#中 lambda表示式，ES6中的箭頭函式 。   定義： 若java 介面中只有一個抽象方法，我們new 這個介面的例項時需要實現這個唯一的抽象方法，除此之外我們還可以使用一種新的表達方式來new這個介面的例項物件，這就是

Java8-lambda表示式總結

lambda表示式總結 lambda表示式是java8新特性,主要有如下極大用處 1.簡化匿名內部類 public class LambdaDemo { @Test public void test01() { // 使用匿名內部類

Java8-Lambda表示式的5種形式

形式一： 這種寫法沒有引數，用一對圓括號表示。 Runnable noArguments = () -> System.out.println("Hello World"); 形式二

Java8 Lambda表示式 函數語言程式設計

什麼是λ表示式 λ表示式本質上是一個匿名方法。讓我們來看下面這個例子： public int add(int x, int y) { return x + y; } 轉成λ表示式後是這個樣子： (int x, int y) -> x + y; 引數型別也可以省略，Jav

java8-lambda表示式

什麼是Lambda表示式 這裡首先要提到一個概念：函式式介面 Java中只有一個抽象方法的介面，用來表示lambda表示式的型別，JAVA8中新增了許多函式式介面。比如斷言介面Predicate，表示函式的Function等。 簡單的說，如果你接觸過C++，C#之類的程式

Java8————Lambda表示式（二）

Lambda表示式 使用匿名類的時候有一個問題是，如果你的匿名類（譯者注：匿名類內部類就是為了實現某些介面而存在的）實現非常簡單，比如一個只包含一個方法的介面，那麼匿名類的語法可能會有些笨拙和不清晰。這種情況下，你通常要試著去傳入一個函式作為另一個方法的引數，比如，當某

(轉)Java8 Lambda表示式教程-入門

1. 什麼是λ表示式 λ表示式本質上是一個匿名方法。讓我們來看下面這個例子：     public int add(int x, int y) {         return x + y;     } 轉成λ表示式後是這個樣子：         (int x, int y) -> x + y;

Spark2.x之RDD支援java8 lambda表示式

1、非lambda實現的java spark wordcount程式 public class WordCount { public static void main(String[] args) { SparkConf conf = new Spa

java8 lambda 表示式的運用

函式式介面： 如果一個介面只有一個抽象方法，那麼該介面就是一個函式式介面 如果我們在某個介面上申明瞭FunctionalInterface 註解，那麼編譯器就會按照函式式介面的定義來要求該介面 如果某個介面只有一個抽象方法，但我們並沒有給該介面申明Functional

java8-Lambda表示式介紹

簡介  Lambda，“語法糖”，是一個匿名函式，我們可以把Lambda表示式理解為是一個可以傳遞的程式碼（將程式碼像資料一樣進行傳遞）。可以寫出更簡潔、更靈活的程式碼。作為一種更緊湊的程式碼風格，使java的語言表達能力得到了提升。 為什麼使用Lambda表示

java8 Lambda表示式和Stream Api

兩個用於測試的類 員工: public class Employee { private int id; private String name; private int age; private double salary;

java8 lambda表示式例子

Java 8 剛於幾周前釋出，日期是2014年3月18日，這次開創性的釋出在Java社群引發了不少討論，並讓大家感到激動。特性之一便是隨同釋出的lambda表示式，它將允許我們將行為傳到函式裡。在Java 8之前，如果想將行為傳入函式，僅有的選擇就是匿名類，需要6行程式碼。而

深入理解Java8 Lambda表示式

一、Lambda表示式是什麼？ Lambda表示式有兩個特點：一是匿名函式；二是可傳遞。 匿名函式的應用場景是： 通常在需要一個函式，但又不想費神去命名一個函式的場合下使用。Lambda表示式所表示的匿名函式的內容應該是很簡單的，如果複雜的話，乾脆就去重新定義一個函數了。 可傳遞的應

Java8 lambda表示式學習(1)：匿名內部類

以往簡單地新建一個執行緒是這樣： public class MainApp { public static void main(String[] args) { new Thread(new Runnable() {

Java8 lambda表示式、函式式介面、方法引用

一、函式式介面 什麼是函式式介面呢？ 函式式介面是Java8新增加的內容。如果一個介面只有一個抽象方法，那麼該介面就是函式式介面。 我們知道，在Java8以前的版本，接口裡面的方法都是抽象的方法，如果接口裡只有一個抽象方法，那麼該介面就是函式式介面。而在J

Java8 lambda表示式10個示例

http://www.importnew.com/16436.html Java 8 lambda表示式示例 我個人對Java 8釋出非常激動，尤其是lambda表示式和流API。越來越多的瞭解它們，我能寫出更乾淨的程式碼。雖然一開始並不是這樣。第一次