Moving Toward Inline Classes: JEP 390 and the @ValueBased Annotation
Candidate JEP 390 ("Warnings for Value-Based Classes&") was announced this past week by Mark Reinhold on the OpenJDK jdk-dev mailing list. This is a JDK Enhan...
Join the DZone community and get the full member experience.Join For Free
Candidate JEP 390 ("Warnings for Value-Based Classes") was announced this past week by Mark Reinhold on the OpenJDK jdk-dev mailing list. This is a JDK Enhancement Proposal that may be more exciting in what it indicates (progress toward inline classes) than what it actually is (annotation and warnings about "improper attempts to synchronize on instances" of
@ValueBased-annotated JDK classes that might be come inline classes).
The term " Value-based Classes" was included in the Java SE 8 Javadoc documentation, which identified the following characteristics of "instances of a value-based class" at that time:
finaland immutable (though may contain references to mutable objects)"
- Implement "
toString... solely [computed] from the instance's state and not from its identity or the state of any other object or variable"
- Do NOT use "identity-sensitive operations such as reference equality (
==) between instances, identity hash code of instances, or synchronization on an instances's intrinsic lock"
- "Are considered equal solely based on
equals()" rather than "on reference equality (
- "Instantiated through factory methods which make no committment as to the identity of returned instances" rather than providing accessible constructors
- "Are freely substitutable when equal"
That Java SE 8 documentation also warned that "a program may produce unpredictable results if it attempts to distinguish two references to equal values of a value-based class, whether directly via reference equality or indirectly via an appeal to synchronization, identity hashing, serialization, or any other identity-sensitive mechanism." It further emphasizes, "Use of such identity-sensitive operations on instances of value-based classes may have unpredictable effects and should be avoided." This documentation remains essentially the same today (Java 15). This documentation is linked to from certain identified JDK classes' Javadoc comments. A good overview on value-based classes is available in Nicolai Parlog's blog post " Value-Based Classes."
Although some JDK classes have been identified in their Javadoc as value-based classes since Java 8, JEP 390 aims to provide the annotation
@ValueBased for these types of JDK classes. The annotation is a stronger construct than a comment and is specifically intended to be used in conjunction with "warnings about improper attempts to synchronize on instances of such classes." The advantage of such an annotation is that developers can be warned about current uses in their code to synchronize on instances of classes that may one day be unsuitable for such synchronization. Because some likely significant time will pass between the availability of this warning and the actual coversion of these
@ValueBased-annotated classes to inline classes (the JEP word this as, "several releases before the migration occurs"), developers will have ample opportunity to change the classes upon which they apply synchronization.
The warning about use of JDK classes for synchronization has benefit in its own right. In addition, I think this JEP is an exciting step toward inline types and the JEP is full of details about inline types. Specifically, the first paragraph of the "Motivation" section of JEP 390 states:
The Valhalla Project is pursuing a significant enhancement to the Java programming model in the form of inline classes. Such classes declare their instances to be identity-free and capable of inline or flattened representations, where instances can be copied freely between memory locations and encoded using solely the values of the instances' fields.
Perhaps the most anticipatory sentence in JEP 390 is in the second paragraph of the "Motivation" section (I've added the highlighting): " The design and implementation of inline classes is sufficiently mature that we can confidently anticipate migrating certain classes in the Java Platform to become inline classes in a future release."
The "Motivation" section of JEP 390 also enumerates the "properties" of a "candidate inline class." These are very similar to the characteristics of "value-based classes" listed earlier:
- "Declares only
Object, or a hierarchy of abstract classes that declare no instance fields and have no instance initialization logic"
- "Declares only
privateconstructors, or has deprecated its constructors for removal"
- "Does not promise a unique instance will be created with each factory-method invocation (or any other instance creation mechanism)"
- "Does not rely upon or expose object identity through any of its methods"
- "Declares no synchronized methods, and discourages clients from performing synchronization"
JEP 390 also comments on the not-so-surprising closeness of the listed "properties" of "inline classes" to the characteristics of "value-based classes":
The Java Platform API uses the term value-based class to informally describe certain classes that satisfy similar constraints. If a class is described as value-based then it will probably be able to become an inline class.
JEP 390 explains that the
@ValueBased annotation "will be introduced to indicate a class, interface, or method result for which no instances are expected to rely on object identity." The annotation is intended to "communicate to developers that they should exercise caution when using
== or identityHashCode, and should not perform synchronization."
One of the other sections of JEP 390 that is particularly interesting to me is the section in the "Description" that lists likely "declarations in the Java Platform API and the JDK" to which the
@ValueBased annotation may be applied. These include the "primitive wrapper classes" (perhaps one of the categories of most commonly used classes with synchronization that will need to be changed), the "optional classes" such as java.util.Optional, many classes in the java.time API, the
java.util "collection factories", and more.
Constructs annotated with
@ValueBased annotation will be highlighted in a javac warning. JEP 390 discusses how compile-time and runtime warnings will eventully become errors in some cases as
@ValueBased-annotated classes become inline classes:
When a @ValueBased class becomes an inline class, the runtime warnings will be superseded by standard errors. At compile time, synchronization on an inline class type may also trigger a standard error. Compiler warnings will continue to be useful for interface types and method results.
@ValueBased annotation and associated warnings will help developers to migrate their Java code that uses identified JDK value-based classes in a way not compatible with inline classes to safer alternatives. JEP 390 not only spells out the details of this, but also provides evidence of the growing maturity of the Project Valhalla work on inline classes.
Published at DZone with permission of Dustin Marx, DZone MVB. See the original article here.
Opinions expressed by DZone contributors are their own.