Java Double.valueOf

Question

在我的工作中，所有开发人员都使用 Double.valueOf 而不是 new Double 构造函数。在每种情况下。对于整数或短，我可以理解缓存值，但不能理解 double和 float .
我看 Double.valueOf in OpenJDK sources :

 /**
 * Returns a {@code Double} instance representing the specified
 * {@code double} value.
 * If a new {@code Double} instance is not required, this method
 * should generally be used in preference to the constructor
 * {@link #Double(double)}, as this method is likely to yield
 * significantly better space and time performance by caching
 * frequently requested values.
 *
 * @param  d a double value.
 * @return a {@code Double} instance representing {@code d}.
 * @since  1.5
 */
public static Double valueOf(double d) {
    return new Double(d);
}

所以它只是调用 Double s 构造函数。
我可以理解为什么存在与整数/短一致的方法...
但对该方法的评论:

this method should generally be used in preference to the constructor

在我看到它对每个 valueOf() 的相同评论后方法。 (整数，短...)
评论是假的？还是其他进程干预？
我听说过 Java 中的内在方法，下一步是在热点代码和 vmSymbol.hpp 中搜索

/* boxing methods: */                                                                                                 \
   do_name(    valueOf_name,              "valueOf")                                                                    \
  do_intrinsic(_Boolean_valueOf,          java_lang_Boolean,      valueOf_name, Boolean_valueOf_signature, F_S)         \
   do_name(     Boolean_valueOf_signature,                       "(Z)Ljava/lang/Boolean;")                              \
  do_intrinsic(_Byte_valueOf,             java_lang_Byte,         valueOf_name, Byte_valueOf_signature, F_S)            \
   do_name(     Byte_valueOf_signature,                          "(B)Ljava/lang/Byte;")                                 \
  do_intrinsic(_Character_valueOf,        java_lang_Character,    valueOf_name, Character_valueOf_signature, F_S)       \
   do_name(     Character_valueOf_signature,                     "(C)Ljava/lang/Character;")                            \
  do_intrinsic(_Short_valueOf,            java_lang_Short,        valueOf_name, Short_valueOf_signature, F_S)           \
   do_name(     Short_valueOf_signature,                         "(S)Ljava/lang/Short;")                                \
  do_intrinsic(_Integer_valueOf,          java_lang_Integer,      valueOf_name, Integer_valueOf_signature, F_S)         \
   do_name(     Integer_valueOf_signature,                       "(I)Ljava/lang/Integer;")                              \
  do_intrinsic(_Long_valueOf,             java_lang_Long,         valueOf_name, Long_valueOf_signature, F_S)            \
   do_name(     Long_valueOf_signature,                          "(J)Ljava/lang/Long;")                                 \
  do_intrinsic(_Float_valueOf,            java_lang_Float,        valueOf_name, Float_valueOf_signature, F_S)           \
   do_name(     Float_valueOf_signature,                         "(F)Ljava/lang/Float;")                                \
  do_intrinsic(_Double_valueOf,           java_lang_Double,       valueOf_name, Double_valueOf_signature, F_S)          \
   do_name(     Double_valueOf_signature,                        "(D)Ljava/lang/Double;")       

所以在我 grep Double.valueOf 之后在源代码中，我找到了 withebox.cpp

static jobject doubleBox(JavaThread* thread, JNIEnv* env, jdouble value) {
  return box(thread, env, vmSymbols::java_lang_Double(), vmSymbols::Double_valueOf_signature(), value);
}

和框方法代码:

template <typename T>
static jobject box(JavaThread* thread, JNIEnv* env, Symbol* name, Symbol* sig, T value) {
  ResourceMark rm(thread);
  jclass clazz = env->FindClass(name->as_C_string());
  CHECK_JNI_EXCEPTION_(env, NULL);
  jmethodID methodID = env->GetStaticMethodID(clazz,
        vmSymbols::valueOf_name()->as_C_string(),
        sig->as_C_string());
  CHECK_JNI_EXCEPTION_(env, NULL);
  jobject result = env->CallStaticObjectMethod(clazz, methodID, value);
  CHECK_JNI_EXCEPTION_(env, NULL);
  return result;
}

而这段代码...
好吧，我还没进阶。这个方法 box() 真的是在服务器模式下调用的吗？
简历的 3 个问题 :D

JVM 拦截 Double.valueOf()调用此框方法？

Double.valueOf不使用 JDK 源代码，也不做 new Double() ?

评论在Double.valueOf()只是一个转储复制/粘贴，Double.valueOf和 new Double有同样的效果吗？

Answer 1

Integer(int) , Double(double)并且类似的构造函数已被弃用(是的，它们实际上被标记为 @Deprecated )，因为 Java 9 作为 JEP 277 的一部分.
deprecation comment说

The static factory valueOf(double) is generally a better choice, as it is likely to yield significantly better space and time performance.

尽管 OpenJDK 目前不缓存盒装 double ，静态工厂方法为 future 的优化开辟了道路。如果决定在 JVM 或类库中改进 double 自动装箱，应用程序将自动从优化中受益，而无需用户端进行任何更改。

另一个原因是Double.valueOf确实是 HotSpot 中的一个内在方法。 JVM knows关于自动装箱方法，并在 EliminateAutoBox 中使用这些知识优化。
有两个相关的优化:EliminateAllocations 和 EliminateAutoBox。尽管它们都由 Escape Analysis 提供并且看起来相似，但它们应用在略有不同的上下文中，因此可能会发生一种优化有效而另一种无效的情况，反之亦然。
当自动装箱消除成功时，例如当 JIT 编译器发现匹配 valueOf和 doubleValue调用，并且对象没有转义，优化器完全摆脱了这两个调用。
顺便说一句，提到的Whitebox代码无关紧要。除了用于内部 HotSpot 测试目的之外，它不会被使用。

项目Valhalla ，现在正在积极开发中，导致对原始包装器的全面重新思考。
current idea是使int , double等inline types , 与 Integer和 Double他们的引用预测。作为迁移步骤，Integer和 Double将成为密封的抽象类，因此将无法通过构造函数实例化它们。
因此，将弃用构造函数视为 Valhalla 项目的中间步骤。通过鼓励使用工厂方法，JDK 开发人员为他们可以在幕后进行的许多优化扫清了道路，包括内联 Double尽可能的实例。