• 售前

  • 售后

热门帖子
入门百科

Android开发太难了:Java Lambda ≠ Android Lambda (上)

[复制链接]
123457751 显示全部楼层 发表于 2022-1-12 12:12:23 |阅读模式 打印 上一主题 下一主题
本文已授权个人公众号「鸿洋」原创发布。
  我又来了,继续回归写作中,目标 1 月 2 篇。
需要两篇才能阐述清楚Java Lambda ≠ Android Lambda,本篇为上篇,先解释清楚 Java Lambda 的一些知识。
耐心阅读本文,你一定会有收获。
一、Java Lambda 不等于 匿名内部类

   测试环境JDK8。
  首先我们看一段比较简单的代码片段:
  1. <code>public class TestJavaAnonymousInnerClass {
  2.     public void test() {
  3.         Runnable runnable = new Runnable() {
  4.             @Override
  5.             public void run() {
  6.                 System.out.println("hello java lambda");
  7.             }
  8.         };
  9.         runnable.run();
  10.     }
  11. }
复制代码
先问个简单的问题,如果我javac编译一下,你觉得会生成几个class文件?
不用问,肯定是两个,一个是TestJavaLambda.class,一个是TestJavaLambda$1.class,那么试下:

没错,确实两个,扎实的Java基础怎么会被这种问题打败。
大家都知道上面这个匿名内部类的写法,我们可以换成lambda表达式的写法对吧,甚至编译器都会提醒你使用lambda,我们改成lambda表达式的写法:
  1. <code>public class TestJavaLambda {
  2.     public void test() {
  3.         Runnable runnable = () -> {
  4.             System.out.println("hello java lambda");
  5.         };
  6.         runnable.run();
  7.     }
  8. }
复制代码
再问个简单的问题,如果我javac编译一下,你觉得会生成几个class文件?
嗯…你在搞我?这和刚才的问题有啥区别?
还认为是两个吗?我们再javac试一下?

不好意思,只有一个class文件了。
那么,我的一个新的问题来了:
Java匿名内部类的写法和Lambda表达式的写法,在编译期这么看肯定有区别的,那么有何区别?
二、Java Lambda的背后,invokedynamic的出现

看这类问题,第一件事肯定是对比字节码了,那我们javap -v 一哈,看一下test()方法区别:
匿名内部类的test():
  1. <code>public void test();
  2.     descriptor: ()V
  3.     flags: ACC_PUBLIC
  4.     Code:
  5.       stack=3, locals=2, args_size=1
  6.          0: new           #2                  // class com/example/zhanghongyang/blog02/TestJavaAnonymousInnerClass$1
  7.          3: dup
  8.          4: aload_0
  9.          5: invokespecial #3                  // Method com/example/zhanghongyang/blog02/TestJavaAnonymousInnerClass$1."<init>":(Lcom/example/zhanghongyang/blog02/TestJavaAnonymousInnerClass;)V
  10.          8: astore_1
  11.          9: aload_1
  12.         10: invokeinterface #4,  1            // InterfaceMethod java/lang/Runnable.run:()V
  13.         15: return
复制代码
很简单,就是new了一个TestJavaAnonymousInnerClass$1对象,然后调用其run()方法。
   有个比较有意思的,就是调用构造方法的时候先aload_0,0就是当前对象this,把this传过去了,这个就是匿名内部类可以持有外部类对象的秘密,其实把当前对象this引用给了人家。
  再来看lambda的test():
  1. <code>public void test();
  2.     descriptor: ()V
  3.     flags: ACC_PUBLIC
  4.     Code:
  5.       stack=1, locals=2, args_size=1
  6.          0: invokedynamic #2,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable;
  7.          5: astore_1
  8.          6: aload_1
  9.          7: invokeinterface #3,  1            // InterfaceMethod java/lang/Runnable.run:()V
  10.         12: return
复制代码
和匿名内部类不同,取而代之的是一个invokedynamic指令。
如果大家比较熟悉Java字节码方法调用相关,应该经常会看到一个问题:invokespecial,invokevirtual,invokeinterface,invokestatic,invokedynamic有和区别?
invokespecial 其实上面一段字节码上也出现了,一般指的是调用super方法,构造方法,private方法等;special嘛,指定的意思,调用的都是一些确定调用者的方法。
你可能会问,调用一个类的方法,调用者还能有不确定的时候?
有呀,比如重载,是不是能将父类的方法调用转而变成子类的?
所以类中非private成员方法,一般调用指令为invokevirtual。
invokeinterface,invokestatic字面意思理解就可以了。
   这块大概解释是这样的,如果有困惑自己打字节码看就好了,例如抽象类抽象方法调用和接口方法调用指令一样吗?加了final修饰的方法不能被复写,指令会有变化吗?
  最后一个就是invokedynamic了:
一般很罕见,今天我们也算是见到了,在Java lambda表达式的时候能够见到。
一些深入的研究,可以看这里:
每日一问 | Java中匿名内部类写成 lambda,真的只是语法糖吗?
我们现在知道使用了lambda表达式之后,和匿名内部类去比较,字节码有比较大的变化,那么更好奇了:
lambda表达式运行的时候,背后到底是什么样的呢?
三、lambda表达式不是真的没有内部类生成

想了解一段代码运行时状态,最简单的方式是什么呢?
嗯…debug?
现在IDE都越来越智能了,很多时候debug一些编译细节都给你抹去了。
有个比较简单的方式,打堆栈,我们修改下代码:
  1. <code>public class TestJavaLambda {
  2.     public void test() {
  3.         Runnable runnable = () -> {
  4.             System.out.println("hello java lambda");
  5.             
  6.             int a = 1/0;
  7.         };
  8.         runnable.run();
  9.     }
  10.     public static void main(String[] args) {
  11.         new TestJavaLambda().test();
  12.     }
  13. }
复制代码
运行下,看下出错的堆栈:
  1. <code>hello java lambda
  2. Exception in thread "main" java.lang.ArithmeticException: / by zero
  3.         at com.example.zhanghongyang.blog02.<code>TestJavaLambda.lambda$test$0(TestJavaLambda.java:8)
  4.         at <code>com.example.zhanghongyang.blog02.TestJavaLambda.test(TestJavaLambda.java:10)
  5.         at <code>com.example.zhanghongyang.blog02.TestJavaLambda.main(TestJavaLambda.java:14)
复制代码
看下到底和何方神圣调用的我们的run方法:
嗯…最后的堆栈是:
  1. <code>TestJavaLambda.lambda$test$0(TestJavaLambda.java:8)
复制代码
是我们TestJavaLambda中的lambda$test$0方法调用的?
是我们刚才发编译看漏了,还有这个方法?我们再反编译看下:
  1. <code>javap /Users/zhanghongyang/repo/KotlinLearn/app/src/main/java/com/example/zhanghongyang/blog02/TestJavaLambda.class
  2. Compiled from "TestJavaLambda.java"
  3. public class <code>com.example.zhanghongyang.blog02.TestJavaLambda {
  4.   public <code>com.example.zhanghongyang.blog02.TestJavaLambda();
  5.   public void test();
  6.   public static void main(java.lang.String[]);
  7.   private void lambda$test$0();
  8. }
复制代码
  这次javap -p 查看,-p代表private方法也输出出来。
  还真有这个方法,看下这个方法的字节码:
  1. <code>private static void lambda$test$0();
  2.     descriptor: ()V
  3.     flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC
  4.     Code:
  5.       stack=2, locals=0, args_size=0
  6.          0: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
  7.          3: ldc           #8                  // String hello java lambda
  8.          5: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
  9.          8: return
  10.       LineNumberTable:
  11.         line 7: 0
  12.         line 8: 8
复制代码
很简单,就是我们上面lambda表达式{}里面的内容,打印一行日志。
那这个方法是test调用的?不对呀,这个堆栈好像有问题,我们在回头看下刚才堆栈:
  1. Exception in thread "main" java.lang.ArithmeticException: / by zero        at com.example.zhanghongyang.blog02.<code>TestJavaLambda.lambda$test$0(TestJavaLambda.java:8)        at <code>com.example.zhanghongyang.blog02.TestJavaLambda.test(TestJavaLambda.java:10)        at <code>com.example.zhanghongyang.blog02.TestJavaLambda.main(TestJavaLambda.java:14)
复制代码
有没有发现这个堆栈太过于简单了,我们的Runnable.run的调用栈呢?
这个堆栈应该是被简化了,那我们再加一行日志,看下run()方法执行时,自己身处于哪个类?
我们在run方法里面加了一行
  1. <code>System.out.println(this.getClass().getCanonicalName());
复制代码
看下输出:
  1. <code>com.example.zhanghongyang.blog02.TestJavaLambda
复制代码
嗯…其实我们执行了一个废操作,当前这个方法里面的代码都被放到lambda$test$0()了,当然输出是TestJavaLambda。
不行了,我要放大招了。
我们修改下方法,让这个进程活的久一点:
  1. public void test() {    Runnable runnable = () -> {        System.out.println("hello java lambda");        <code>System.out.println(this.getClass().getCanonicalName());        // 新增        try {            Thread.sleep(1000000);        } catch (InterruptedException e) {            e.printStackTrace();        }        int a = 1 / 0;    };    runnable.run();}
复制代码
运行后…
切到命令行,执行jps命令,查看当前程序进程的pid:
  1. <code>java zhanghongyang$ jps
  2. 99315 GradleDaemon
  3. 3682 TestJavaLambda
  4. 21298 Main
  5. 3685 Jps
  6. 3258 GradleDaemon
  7. 1275
  8. 3261 KotlinCompileDaemon
复制代码
看到了3682,然后执行
  1. <code>jstack 3682
复制代码

太感人了,终于把这行隐藏的run方法的堆栈找出来了。
   这里大家不要太在意jps,jstack这些指令,都是jdk自带的,你就知道能查堆栈就行了,别出去搜这两个命令去啦,文章看完再说。
另外获取堆栈其实也能通过方法调用,小缘是通过Reflection.getCallerClass看的。
  到现在我们具体真相又进了一步:
我们lambda$test$0()方法是这个对象:<code>com.example.zhanghongyang.blog02.TestJavaLambda$$Lambda$1/1313922862的run方法调用的。
我们又能下个结论了:
文中lambda表达式的写法,在运行时,会帮我们生成中间类,类名格式为 原类名$$Lambda$数字,然后通过这个中间类最终完成调用。
那么你可能表示不服:
你说运行时生成就生成呀?你拿出来给我看看?
嗯…等会我拿出来给你看。
不过我们先思考另一个问题。
四、编译产物中遗漏的信息

上文我们一直在说:

  • 对于文中例子中的Lambda表达式编译时没有生成中间类;
  • 运行时帮我们生成了中间类;
那有个很明显的问题,编译时你没给我生成,运行时生成了;运行时它怎么知道要不要生成,生成什么样的类,你编译产物就那一个class文件,里面肯定要包含这类信息的呀?
是这么个道理。
我们再次发编译javap -v查看,在输出信息的最后:
  1. <code>SourceFile: "TestJavaLambda.java"
  2. InnerClasses:
  3.      public static final #78= #77 of #81; //Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles
  4. BootstrapMethods:
  5.   0: #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;
  6.     Method arguments:
  7.       #36 ()V
  8.       #37 invokespecial com/example/zhanghongyang/blog02/TestJavaLambda.lambda$test$0:()V
  9.       #36 ()V
复制代码
果然包含一段信息,而且包含TestJavaLambda.lambda$test$0关键词。
大家不用管那么多,你就知道,文中lambda的例子,会在编译的class文件中新增一个方法lambda$test$0(),并且会携带一段信息告知JVM在运行时创建一个中间class。
   其实LambdaMetafactory.metafactory正是用来生成中间class的,jdk中也有相关类可以查看,后续我们再详细说这个。
  五、把中间类拿出来看看?

我们一直说运行时帮我们生成了一个中间类,类名大概为:TestJavaLambda$$Lambda$1,但是口说无凭,得拿出来大伙才信,对吧。
还好不是说我吃了两碗凉粉…
我们刚才说了JVM帮我们生成了中间类,其实java在运行的时候可以带很多参数,其中有个系统属性很神奇,我用给你们看:
  1. java -Djdk.internal.lambda.dumpProxyClasses <code>com.example.zhanghongyang.blog02.TestJavaLambda
复制代码
懂了吧,加上这个系统属性运行,可以dump出生成的类:

是不是有点意思。
   其实动态代理中间也会生成代理类,也可以通过类似方式导出。
  然后我们看看这个类呗,这个类我们就不太在乎细节了,直接AS里面看反编译之后的:

真简单…
所以,本文中的例子,Lambda表达式和匿名内部类的区别还是挺大的,大家只要了解:

  • invokedynamic可以用于lambda;
  • Java lambda表达式的中间类并不是没有,而是在首次运行时生成的。
至于性能问题,影响应该是微乎其微的,几乎没有的。
下面有个灵魂一问:
你看这些有啥用?
毕竟我是搞Android的,其实我更在乎Android中lambda的实现,所以就先以Java Lambda为开始了,至于你问我为啥要看Android Lambda实现,毕竟现在经常要字节码插抓桩,自定义Transform,对于一些类背后的行为还是要搞清楚的。
但是,大家一定要注意,本文讲的是 Java lambda 的原理。
不要套用到Android上!
不要套用到Android上!
不要套用到Android上!
那 Android Lambda 是怎么一回事,后续会单独写一篇,Android 脱糖与D8 的一些事儿,还想起来上次有个同事被Android Lambda 坑了一次,会一起写出来。
   本文基于1.8.0_181。
  告辞,下篇见!
   你可以添加微信公众号:鸿洋,这样可以第一时间接收文章。

来源:https://blog.caogenba.net/lmj623565791/article/details/122440444
免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?立即注册

x

帖子地址: 

回复

使用道具 举报

分享
推广
火星云矿 | 预约S19Pro,享500抵1000!
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

草根技术分享(草根吧)是全球知名中文IT技术交流平台,创建于2021年,包含原创博客、精品问答、职业培训、技术社区、资源下载等产品服务,提供原创、优质、完整内容的专业IT技术开发社区。
  • 官方手机版

  • 微信公众号

  • 商务合作