Java8新特性 Lambda底层实现原理

前言

经常会在写业务代码的时候，有这样的需求：

筛选出条件为XX的实体类ID List

List<Long> waitTaskList = wflInsTaskList.stream().filter(wflInsTask -> {
                return wflInsTask.getArrivalStatus().equals(WflInsTask.ARRIVAL_STATUS_NOT_ARRIVED);
            }).map(WflInsTask::getTaskId).distinct().collect(Collectors.toList());

Java8之Lambda

下文内容默认以JDK8为前提

什么是Lambda

Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的Java代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。

Lambda 表达式描述了一个代码块（或者叫匿名方法），可以将其作为参数传递给构造方法或者普通方法以便后续执行。如：

() -> System.out.println("hello");

() 为 Lambda 表达式的参数列表（允许没有参数），-> 标识这串代码为 Lambda 表达式（也就是说，看到 -> 就知道这是 Lambda，Groovy的闭包语法也类似），System.out.println("hello") 就是执行的代码，将“hello”打印到标准输出流。

以Runnable接口为例，原来我们创建一个线程并启动它是这样的：

public class Test {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        }).start();
    }
}

通过 Lambda 只需要这样：

public class Test {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("hello")).start();
    }
}

我们看Runnable接口源码：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

其中@FunctionalInterface注解中有这样一段描述：

/*
 * <p>Note that instances of functional interfaces can be created with
 * lambda expressions, method references, or constructor references.
 */

说明通过 @FunctionalInterface 标记的接口可以通过 Lambda 表达式创建实例。

@FunctionalInterface修饰函数式接口的，要求接口中的抽象方法只有一个。有多个抽象方法编译将报错

加不加@FunctionalInterface对于接口是不是函数式接口没有影响，该注解知识提醒编译器去检查该接口是否仅包含一个抽象方法

例如：

public interface Comparator<T> {
    int compare(T o1, T o2);
}
public interface Runnable {
    void run();
}
public interface Callable<V> {
    V call() throws Exception;
}

上面三个接口都只有一个抽象方法，但是三个方法的签名都不一样，这要求Lambda表达式与实现接口的方法签名要一致。下面用函数描述符来表示上述三个方法的签名，箭头前面是方法的入参类型，后面是返回类型。

1. compare：(T, T) -> int，两个泛型T类型的入参，返回int类型

   Lambda表达式：（User u1, User u2） -> u1.getAge - u2.getAge

2. run：() -> void，无入参，无返回值

   Lambda表达式：() -> { System.out.println("hello"); }

3. call：() -> V，无入参，返回一个泛型V类型的对象

   Lambda表达式：() -> new User() //不需要用括号环绕返回值为void的单行方法调用。

语法

Lambda表达式由三部分组成：

1. 参数列表
2. 箭头
3. 主体

有两种风格，分别是：

1. 表达式-风格

   (parameters) -> expression

2. 块-风格

   (parameters) -> { statements; }

其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符 ，读作(goes to)。

例：

1. () -> {}
2. () -> "hello"
3. () -> { return "hello"; }

Java 8中内部类或者Lambda表达式对外部类变量的引用条件放松了，不要求强制的加上final关键字了，但是Java 8中要求这个变量是effectively final

public class LambdaTest {
    public static void main(String[] args) {
        String str = "hello";
        List<String> list = new ArrayList<>();
        list.forEach(s -> {
            // 这行赋值报错 Variable used in lambda expression should be final or effectively final
            // 注释掉，不赋值就是effectively final
            str = "hi";
            System.out.println(str);
        });
    }
}

常用函数式接口

随Lambda一同增加的还有一个java.util.function包，其中定义了一些常见的函数式接口的。比如：

• Function，接受一个输入参数，返回一个结果。参数与返回值的类型可以不同，我们之前的map方法内的lambda就是表示这个函数式接口的；
• Consumer，接受一个输入参数并且无返回的操作。比如我们针对数据流的每一个元素进行打印，就可以用基于Consumer的lambda；
• Supplier，无需输入参数，只返回结果。看接口名就知道是发挥了对象工厂的作用；
• Predicate，接受一个输入参数，返回一个布尔值结果。比如我们在对数据流中的元素进行筛选的时候，就可以用基于Predicate的Lambda；

这里只解释其中一种，更多的自己去了解吧。

public interface Predicate<T> {
    boolean test(T t);
}

test：T -> boolean，接收一个泛型T对象，返回一个boolean。

适用场景：表示一个涉及类型T的布尔表达式。

// 判断空白字符串
Predicate<String> isBlankPredicate = s -> s != null && s.trim().length() == 0;
isBlankPredicate.test("  "); // true
// 判断用户年龄是否大于20
Predicate<User> agePredicate = u -> u.getAge() > 20;
agePredicate.test(new User(18)); // false

Java是一个强类型的语言，因此参数必须要有类型，如果编译器能够推测出Lambda表达式的参数类型，则不需要我们显示的进行指定。

上述代码中 没有指定s参数类型Stirng，因为编译器会根据Lambda表达式对应的函数式接口Predicate<String>进行自动推断。

复合Lambda表达式---以比较器复合（Comparator）为例

使用 Comparator 对用户年龄按从大到小进行排序：

List<User> users = Arrays.asList(new User("zhangsan", 30), 
                                   new User("lisi", 22), 
                                   new User("wangwu", 18));
users.sort(Comparator.comparing(User::getAge).reversed());

Comparator.comparing源码：

@FunctionalInterface
public interface Comparator<T> {
    public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }
   default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
   }
}

Java 8中在接口中增加了默认实现这种函数，其实在很大程序上违背了接口具有抽象这种特征的，增加default实现主要原因是因为考虑兼容及代码的更改成本，例如，在Java 8中向iterator这种接口增加一个方法，那么实现这个接口的所有类都要需实现一遍这个方法，那么Java 8需要更改的类就太多的，因此在Iterator接口里增加一个default实现，那么实现这个接口的所有类就都具有了这种实现

方法引用

当在Lambda表达式中直接调用了一个方法时可以使用，其写法为目标引用::方法名称

1. 指向静态方法的方法引用

   Function<String, Integer> fun = s -> Integer.parseInt(s);
   Function<String, Integer> fun = Integer::parseInt;

2. 指向任意类型实例方法的方法引用

   Function<String, Integer> fun = s -> s.length();
   Function<String, Integer> fun = String::length;

3. 指向现存外部对象实例方法的方法引用

   String s = "hello";
   Supplier<Integer> len = () -> s.length();
   Supplier<Integer> len = s::length;

实现原理

以下文代码为例：

public class LambdaTest {
    @FunctionalInterface
    public interface LambdaDemo{
        public void runLambda();
    }
    public static void doSomething(LambdaDemo demo){
        demo.runLambda();
    }

    public static void main(String[] args) {
        doSomething(()->System.out.println("hello world!"));
    }
}

执行javac LambdaTest.java编译后生成两个class文件

javap -p LambdaTest 输出所有类和成员

由此可以看出Lambda 表达式在 Java 8 中首先会生成一个私有的静态函数，这个私有的静态函数干的就是 Lambda 表达式里面的内容。

javap -v LambdaTest输出行号、本地变量表信息、反编译汇编代码、当前类用到的常量池等信息。

其中main方法执行了一条invokedynamic指令。invokedynamic出现的位置代表一个动态调用点，invokedynamic指令后面会跟一个指向常量池的调用点限定符，这个限定符会被解析为一个动态调用点。依据这个可以找到对应的动态调用引导方法java.lang.invoke.CallSite。

对应常量池中的静态方法：

而#0在字节码最后的BootstrapMethods中，Method arguments#29代表这个Lambda表达式调用代码

根据BootstrapMethods对应的#27可以找到此处Lambda InvokeDynamic指令对应的引导方法是LambdaMetafactory.metafactory，返还一个CallSite

LambdaMetafactory.java

    public static CallSite metafactory(MethodHandles.Lookup caller,
                                       String invokedName,
                                       MethodType invokedType,
                                       MethodType samMethodType,
                                       MethodHandle implMethod,
                                       MethodType instantiatedMethodType)
            throws LambdaConversionException {
        AbstractValidatingLambdaMetafactory mf;
        // 通过new一个InnerClassLambdaMetafactory并调用buildCallSite
        // 为Lambda表达式生成了一个内部类
        mf = new InnerClassLambdaMetafactory(caller, invokedType,
                                             invokedName, samMethodType,
                                             implMethod, instantiatedMethodType,
                                             false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY);
        mf.validateMetafactoryArgs();
        return mf.buildCallSite();
    }

关于内部类，在运行时加上vm参数-Djdk.internal.lambda.dumpProxyClasses，可以发现生成了!

`

public class LambdaTest {
    @FunctionalInterface
    public interface LambdaDemo{
        public void runLambda();
    }
    public static void doSomething(LambdaDemo demo){
        demo.runLambda();
    }

    public static void main(String[] args) {
        doSomething(()->System.out.println("hello world!"));
    }
  
    private static void lambda$main$0() {
        System.out.println("hello world!");
    }
  
    // 内部类
      final class Lambda$1 {
        @Override
        public void runLambda() {
            lambda$main$0();
        }
    }
}

由此可以知道Lambda表达式，编译器在类中生成一个静态函数，运行时调以内部类形式调用该静态函数。

http://ifeve.com/jvm%E4%B9%8B%E5%8A%A8%E6%80%81%E6%96%B9%E6%B3%95%E8%B0%83%E7%94%A8%EF%BC%9Ainvokedynamic/

Java8之Stream

Stream是Java提供的一个接口，该接口允许以声明式的写法处理数据，可以把操作链接起来，形成数据处理流水线，还能将数据处理任务并行化。（与IO流无关）

具体的内容且看下回。。

感想

Lambda的行为参数化思想

Lambda简化了代码，但并不是完美的，性能方面，在非并行计算中，很多计算未必有传统的for性能要高，也不易调试。所以具体的应用还应参考业务的需求。

本文只是对Java8部分特性做了介绍，还有很多内容需要自己去学习研究的。就是想说，技术是很长的一条路，要主动并不排斥接收新的知识，才不会停滞不前。