RFR: 8330465: Stable Values and Collections (Internal) [v2]

[Viktor Klang]

On Tue, 14 May 2024 14:51:20 GMT, Per Minborg <pminborg at openjdk.org> wrote:

>> # Stable Values & Collections (Internal)
>> 
>> ## Summary
>> This PR proposes to introduce an internal _Stable Values & Collections_ API, which provides immutable value holders where elements are initialized _at most once_. Stable Values & Collections offer the performance and safety benefits of final fields while offering greater flexibility as to the timing of initialization.
>> 
>> ## Goals
>>  * Provide an easy and intuitive API to describe value holders that can change at most once.
>>  * Decouple declaration from initialization without significant footprint or performance penalties.
>>  * Reduce the amount of static initializer and/or field initialization code.
>>  * Uphold integrity and consistency, even in a multi-threaded environment.
>>  
>> For more details, see the draft JEP: https://openjdk.org/jeps/8312611
>> 
>> ## Performance 
>> Performance compared to instance variables using an `AtomicReference` and one protected by double-checked locking under concurrent access by 8 threads:
>> 
>> 
>> Benchmark                       Mode  Cnt  Score   Error  Units
>> StableBenchmark.instanceAtomic  avgt   10  1.576 ? 0.052  ns/op
>> StableBenchmark.instanceDCL     avgt   10  1.608 ? 0.059  ns/op
>> StableBenchmark.instanceStable  avgt   10  0.979 ? 0.023  ns/op <- StableValue (~40% faster than DCL)
>> 
>> 
>> Performance compared to static variables protected by `AtomicReference`, class-holder idiom holder, and double-checked locking (8 threads):
>> 
>> 
>> Benchmark                       Mode  Cnt  Score   Error  Units
>> StableBenchmark.staticAtomic    avgt   10  1.335 ? 0.056  ns/op
>> StableBenchmark.staticCHI       avgt   10  0.623 ? 0.086  ns/op
>> StableBenchmark.staticDCL       avgt   10  1.418 ? 0.171  ns/op
>> StableBenchmark.staticList      avgt   10  0.617 ? 0.024  ns/op
>> StableBenchmark.staticStable    avgt   10  0.604 ? 0.022  ns/op <- StableValue ( > 2x faster than `AtomicInteger` and DCL)
>> 
>> 
>> Performance for stable lists in both instance and static contexts whereby the sum of random contents is calculated for stable lists (which are thread-safe) compared to `ArrayList` instances (which are not thread-safe) (under single thread access):
>> 
>> 
>> Benchmark                                     Mode  Cnt  Score   Error  Units
>> StableListSumBenchmark.instanceArrayList      avgt   10  0.356 ? 0.005  ns/op
>> StableListSumBenchmark.instanceList           avgt   10  0.373 ? 0.017  ns/op <- Stable list
>> StableListSumBenchmark.staticArrayList        avgt   10  0.352 ? ...
>
> Per Minborg has updated the pull request incrementally with one additional commit since the last revision:
> 
>   Remove text in public class that references an internal class

src/java.base/share/classes/jdk/internal/lang/StableValue.java line 171:

> 169:     /**
> 170:      * {@return a fresh stable value with an unset value where the returned stable's
> 171:      * value is computed in a separate background thread (created via the provided

Suggestion:

     * {@return a fresh stable value with an unset value where the returned stable
     * value is computed in a separate background thread (created via the provided

src/java.base/share/classes/jdk/internal/lang/StableValue.java line 175:

> 173:      * <p>
> 174:      * If the supplier throws an (unchecked) exception, the exception is ignored, and no
> 175:      * value is set.

Is it likely that users will want to be made aware of failures? If so, perhaps it would make sense to make sure that the Exception hits the UncaughtExceptionHandler? 🤔

-------------

PR Review Comment: https://git.openjdk.org/jdk/pull/18794#discussion_r1600296959
PR Review Comment: https://git.openjdk.org/jdk/pull/18794#discussion_r1600298211