标签: jvm-hotspot

共识似乎是将成员变量标记为final有一个性能优势,因为它们永远不需要从主内存重新加载.我的问题是,当变量无法改变时,javac或Hotspot会自动为我做这件事.例如,javac将在下面的这堂课中制作'x'决赛......

public class MyClass {
   private String x;

   MyClass(String x) {
      this.x = x;
   }

   public String getX() {
      return x;
   }
}

在次要问题上,有没有人提出经验证据表明成员最终会使代码运行得更快？在进行远程调用或数据库查找的任何应用程序中,任何好处肯定都可以忽略不计？

在linux上运行java应用程序时收到以下错误,导致jvm崩溃:

#
# A fatal error has been detected by the Java Runtime Environment:
#
#  SIGSEGV (0xb) at pc=0x000000000000003a, pid=7629, tid=140107993413376
#
# JRE version: 6.0_24-b07
# Java VM: Java HotSpot(TM) 64-Bit Server VM (19.1-b02 mixed mode linux-amd64 compressed oops)
# Problematic frame:
# C  0x000000000000003a
#
# If you would like to submit a bug report, please visit:
#   http://java.sun.com/webapps/bugreport/crash.jsp
# The crash happened outside the Java Virtual Machine in native code.
# See problematic frame for where …

当我遇到一个奇怪的结果时,我正在做一些关于对象分配的性能测试.我有以下java代码:

public static long TestMethod(){
    int len = 10000000;
    Object[] obs = new Object[len];
    long t = System.nanoTime();
    for (int i = 0; i < len; i++) {
        obs[i] = new Object();
    }
    return System.nanoTime() - t;
}

public static void main(String... args) throws InterruptedException {
    for(int i = 0; i < 10; i++){
        System.gc();
        System.gc();//Wait for the gc to be finished
        Thread.sleep(1000);
        System.out.println(TestMethod());
    }
}

期望:由于请求操作系统和热点增强的更大内存空间,第一次调用将比第二次调用慢.但第二和第三将几乎相同.

观察结果:

11284734000
799837000
682304000
304736000
380770000
392786000
374279000
381611000
379174000
407256000 …

我有一个Web应用程序,在其生命周期内创建/销毁几个小程序.在创建新applet时,JVM会定期启动第二个实例.applet共享各种内存结构,因此JVM重新启动会导致整个应用程序出现故障.

这是我唯一的线索.在控制台中,这是applet启动导致新JVM启动时所写的内容:

security: SSV validation:
    running: 1.7.0_51
    requested: null
    range: null
    javaVersionParam: null
    Rule Set version: null
network: Created version ID: 1.7.0.51
network: Created version ID: 1.7.0.51
security: continue with running version
basic: AppletRelaunch due to health
network: Created version ID: 1.9
network: Created version ID: 1.8
network: Created version ID: 1.7
network: Created version ID: 1.6
network: Created version ID: 1.5
network: Created version ID: 1.4
network: Created version ID: 1.3
basic: WARNING - specified JRE version, null is …

我在MacOS上运行Oracle Java 7(OSX 10.7.5)

java -version:

Java version "1.7.0_40"
Java(TM) SE Runtime Environment (build 1.7.0_40-b43)
Java HotSpot(TM) 64-Bit Server VM (build 24.0-b56, mixed mode)

我最近读到了有关DCEVM的内容,我非常好奇地试用它.但是,我对它的兼容性感到困惑.

根据二进制文件下载页面,有OpenJDK Java 7更新51,构建3的二进制文件.我不太确定这与我目前在我的机器上的Java版本有什么关系.

安装JRE是否需要与DCEVM Hotspot版本匹配？我是否需要安装OpenJDK 7_51_3才能使用有问题的DCEVM？或者我可以使用Oracle JRE安装热点VM吗？

我不完全确定JRE/JDK附带的所有实用程序如何与HotSpot VM交互,如果它们都必须具有相同的构建,那么编译后的字节代码应该能够在任何JVM上运行相同的主要版本号.

任何人都可以提供一些有关如何将所有这些组件组合在一起

作为后续,有没有人知道我是否可以找到OSX的OpenJDK兼容版本,我可以在其上运行DCEVM for Java 7 update 51,build 3？？

我正在浏览JIT HotSpot编译器日志（-XX:+PrintCompilation -XX:+UnlockDiagnosticVMOptions -XX:+PrintInlining），以确保正在优化/编译重要/热门方法。该方法显示：

已经编译成一个大方法

这意味着什么？JIT是否正确优化/内联了我的方法？

Oracle Wiki的这种解释并没有使我得出任何结论：

已经编译成一个大方法：已经有从调用站点调用的方法的已编译代码，并且为其生成的代码大于InlineSmallCode

这意味着什么？这是否意味着我的代码已经过优化/内联，或者HotSpot现在正在跳过它，因为它是在其他地方编译的？

有许多文章/网页指出，JRockit将被合并到新版本的JVM或JDK 8中：

https://zh.wikipedia.org/wiki/JRockit

http://www.mythics.com/about/blog/answers-to-common-questions-on-java-versions-editions

哪里可以下载Java 7的JRockit？

但是我找不到任何文章/网页说明JRockit已真正合并到JDK 8中。是否有任何更新的消息？还是在JDK 8中实现了JRockit的部分功能，以至于JDK 8的实时性能不如JRockit？谢谢！

在内存数据库的情况下，我们将堆外内存与热点的G1收集器结合使用。

但是，当堆外内存使用量达到MaxDirectMemorySize时，JDK代码会使用触发完整的GC System.gc()。这将导致世界GC长期而痛苦的停顿，这似乎也将所有当前的直播设置都放到了旧世代中，从而绕过了幸存者（从而增加了裙带关系问题）。设置时不会发生这种情况-XX:+ExplicitGCInvokesConcurrent：GC速度更快，并且尊重幸存者。

由于System.gc()JDK在内部使用了某些东西，为什么热点中默认不启用此选项？这个标志会引起理论上的或实际的问题吗？还是仅出于兼容性原因？是否有人有在生产环境中使用此选项的经验，并遇到过问题？

我继续战斗，以了解VarHandle::setOpaque和VarHandle::getOpaque被真正做的事情。到目前为止，这并不容易-我认为我得到了一些东西（但不会在问题本身中介绍它们，不要糊涂了它们），但总的来说，这对我来说最多是误导。

文档：

返回按程序顺序访问的变量的值...

据我了解，如果我有：

int xx = x; // read x
int yy = y; // read y

这些读取可以重新排序。另一方面，如果我有：

// simplified code, does not compile, but reads happen on the same "this" for example
int xx = VarHandle_X.getOpaque(x); 
int yy = VarHandle_Y.getOpaque(y);

这次不能重新订购吗？这就是“程序顺序”的意思吗？我们是否在谈论在这里插入障碍物以禁止这种重新排序？如果是这样，由于这是两个负载，是否会达到相同的效果？通过：

 int xx = x;
 VarHandle.loadLoadFence()
 int yy = y;

但这变得更加棘手：

...但不能保证相对于其他线程的内存排序效果。

我无法拿出一个例子来假装我理解这部分。

在我看来，该文档针对的是确切知道他们在做什么的人（我绝对不是一个人）...那么有人可以在这里阐明一些信息吗？

在JEP193中，的特定目标之一VarHandles是提供使用FieldUpdaters和的替代方法AtomicIntegers（并避免与之相关的一些开销）。

AtomicIntegers 由于它们是一个单独的对象（它们每个使用大约36个字节，取决于一些因素（例如是否启用压缩的OOP等）），因此在内存方面可能特别浪费。

如果您有很多整数可能需要原子更新（在许多小对象中），则要减少浪费，实质上有三种选择：

• 使用 AtomicFieldUpdater
• 用一个 VarHandle
• 或重新排列代码以AtomicIntegerArray代替对象中的字段。

因此，我决定测试替代方案，并对每种方案的性能含义有所了解。

使用整数字段的原子（易失性模式）增量作为代理，我在2014年中的MacBook Pro上获得以下结果：

Benchmark                         Mode  Cnt          Score          Error  Units
VarHandleBenchmark.atomic        thrpt    5  448041037.223 ± 36448840.301  ops/s
VarHandleBenchmark.atomicArray   thrpt    5  453785339.203 ± 64528885.282  ops/s
VarHandleBenchmark.fieldUpdater  thrpt    5  459802512.169 ± 52293792.737  ops/s
VarHandleBenchmark.varhandle     thrpt    5  136482396.440 ±  9439041.030  ops/s

在此基准测试中，速度VarHandles大约慢了四倍。

我想了解的是开销来自何处？

这是由于签名多态访问方法引起的吗？我在微型基准测试中犯了错误吗？

基准细节如下。

我在2014年中的MacBook Pro上使用以下JVM运行了基准测试

> java -version
openjdk version "11.0.2" 2019-01-15
OpenJDK Runtime Environment AdoptOpenJDK (build 11.0.2+9) …