JVM系列之:JIT中的Virtual Call接口操作

简介

上一篇文章我们讲解了virtual call的定义并举例分析了virtual call在父类和子类中的优化。

jit对类可以进行优化，那么对于interface可不可以做同样的优化么？

一起来看看吧。

最常用的接口list

list应该是大家最最常用的接口了，我想这个大家应该不会反驳。

public interface list<e> extends collection<e> {

今天我们就拿list来做例子，体验一下jit优化接口的奥秘。

还是上代码，要分析的代码如下：

public class testvirtuallistcall {

  public static void main(string[] args) throws interruptedexception {
    list<string> list=new arraylist<>();
    for (int i = 0; i < 10000; i++)
    {
      dowithvmethod(list);
    }
    thread.sleep(1000);
  }

  public static void dowithvmethod(list<string> list)
  {
    list.add("www.jb51.net");
  }
}

如果在命令行运行，大家记得在运行时添加参数-xx:+unlockdiagnosticvmoptions -xx:+printassembly -xx:-inline

直接看jit watcher的结果：

我们可以看到jit中先对arraylist的实现类做了一个比较。

然后调用的是invokeinterface，但是其本质还是invokevirtual,并且我们可以看到这个调用是被优化过了：optimized virtual call。

多个list的调用

同样的，我们可以测试一下多个list子类的情况下怎么调用：

public class testvirtuallistcall2 {

  public static void main(string[] args) throws interruptedexception {
    list<string>[] lists=new list[]{new arraylist<>(),new linkedlist<>()};
    for (int i = 0; i < 10000; i++)
    {
      dowithvmethod(lists[i%2]);
    }
    thread.sleep(1000);
  }

  public static void dowithvmethod(list<string> list)
  {
    list.add("www.jb51.net");
  }
}

同样，使用jit watcher来运行：

我们可以看到jit做了两次对象类型的比较，然后对两个invokeinterface都做了优化。

结果和我们的父类子类结果是一样的。

不一样的list调用

上面我们在做多个list调用的时候，是轮循着来调用的，如果我们先调用arraylist的方法，再调用linkedlist的方法，会有什么不同呢？

一起来看看。

public class testvirtuallistcall3 {

  public static void main(string[] args) throws interruptedexception {
    list<string> list1 = new arraylist<>();
    list<string> list2 = new linkedlist<>();
    for (int i = 0; i < 10000; i++)
    {
      dowithvmethod(list1);
    }
    thread.sleep(1000);
    for (int i = 0; i < 10000; i++)
    {
      dowithvmethod(list2);
    }
    thread.sleep(1000);
  }

  public static void dowithvmethod(list<string> list)
  {
    list.add("www.jb51.net");
  }
}

上面我们先循环arraylist，然后再循环linkedlist。

看下结果有什么不同：

可以看到，jit先比较了arraylist,然后只做了一次方法的优化。

也就是说linkedlist的调用是没有进行代码优化的。

上面的结果是在c2编译器下，也就是level4的编译水平下解析的。

我们看下如果在c1编译器下，也就是level3编译水平下有什么不同。

可以看到c1编译下，所有的invokeinterface都没有进行编译优化，只有在c2编译下，才会进行优化。

不同的jvm版本可能优化方式不一样。大家可以自行实验。

总结

本文用实例展示了virtual call在interface上面的优化使用。

感兴趣的朋友，可以一起讨论。

补充知识：java 8 stream 流已被操作或关闭

在java 8中，stream不能重复使用，一旦被消耗或使用，流将被关闭，类似流水线，水龙头的水一样一去不复返

示例 - 流关闭

查看以下示例，它会抛出一个illegalstateexception，表示“流被关闭”。

testjava8.java

package com.mkyong.java8;
import java.util.arrays;
import java.util.stream.stream;
public class testjava8 {
  public static void main(string[] args) {
    string[] array = {"a", "b", "c", "d", "e"};
    stream<string> stream = arrays.stream(array);
    // loop a stream
    stream.foreach(x -> system.out.println(x));
    // reuse it to filter again! throws illegalstateexception
    long count = stream.filter(x -> "b".equals(x)).count();
    system.out.println(count);
  }
}

output

java.lang.illegalstateexception: stream has already been operated upon or closed
 at java.util.stream.abstractpipeline.(abstractpipeline.java:203)
 at java.util.stream.referencepipeline.(referencepipeline.java:94)
 at java.util.stream.referencepipeline$statelessop.(referencepipeline.java:618)
 at java.util.stream.referencepipeline$2.(referencepipeline.java:163)
 at java.util.stream.referencepipeline.filter(referencepipeline.java:162)
 at com.hostingcompass.whois.range.run.testjava8.main(testjava8.java:25)
 at sun.reflect.nativemethodaccessorimpl.invoke0(native method)
 at sun.reflect.nativemethodaccessorimpl.invoke(nativemethodaccessorimpl.java:62)
 at sun.reflect.delegatingmethodaccessorimpl.invoke(delegatingmethodaccessorimpl.java:43)
 at java.lang.reflect.method.invoke(method.java:498)
 at com.intellij.rt.execution.application.appmain.main(appmain.java:144)

示例 - 重用流

testjava8.java

package com.mkyong.java8; 
import java.util.function.supplier;
import java.util.stream.stream;
 public class testjava8 {
 
  public static void main(string[] args) { 
    string[] array = {"a", "b", "c", "d", "e"};
     supplier<stream<string>> streamsupplier = () -> stream.of(array);
 
    //get new stream
    streamsupplier.get().foreach(x -> system.out.println(x));
 
    //get another new stream
    long count = streamsupplier.get().filter(x -> "b".equals(x)).count();
    system.out.println(count); 
  }
 }

output

a

b

c

d

e

1

每个get()都会返回一个新的流

以上这篇jvm系列之:jit中的virtual call接口操作就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持。