1. Overview
The release of Java SE 17 introduces an update to the API for random number generation – JEP 356.
With this API update, new interface types have been introduced, as well as methods to easily list, find and instantiate generator factories. In addition, a new set of random number generator implementations is now available.
In this tutorial, we’ll compare the new RandomGenerator API with the old Random API. We’ll look at listing all available generator factories and selecting a generator based on its name or property.
We’ll also explore the new API’s thread-safety and performance.
2. Old Random API
First, let’s take a look at Java’s old API for random number generation based on the Random class.
2.1. API Design
The original API consists of four classes with no interfaces:
2.2. Random
The most commonly used random number generator is Random from the java.util package.
To generate a stream of random numbers, we need to create an instance of a random number generator class – Random:
Random random = new Random();
int number = random.nextInt(10);
assertThat(number).isPositive().isLessThan(10);
Here, the default constructor sets the seed of the random number generator to a value that is very likely distinct from any other invocation.
2.3. Alternatives
In addition to java.util.Random, three alternative generators are available to tackle thread safety and security concerns.
All instances of Random are thread-safe by default. However, concurrent use of the same instance across threads may result in poor performance. Therefore, a ThreadLocalRandom class from the java.util.concurrent package is a preferred option for multithreaded systems.
As Random instances are not cryptographically secure, the SecureRandom class enables us to create generators for use in a security-sensitive context.
Finally, the SplittableRandom class from java.util package is optimized for working with parallel streams and fork/join-style computations.
3. New RandomGenerator API
Now, let’s take a look at the new API based on the RandomGenerator interface.
3.1. API Design
The new API provides a better overall design with new interface types and generator implementations:
In the diagram above, we can see how the old API classes fit into the new design. On top of these types, there are several random number generator implementation classes added:
- Xoroshiro group
- Xoroshiro128PlusPlus
- Xoshiro group
- Xoshiro256PlusPlus
- LXM group
- L128X1024MixRandom
- L128X128MixRandom
- L128X256MixRandom
- L32X64MixRandom
- L64X1024MixRandom
- L64X128MixRandom
- L64X128StarStarRandom
- L64X256MixRandom
3.2. Improvement Areas
The lack of interfaces in the old API made it harder to switch between different generator implementations. Therefore, it was difficult for third parties to provide their own implementations.
For example, SplittableRandom was completely detached from the rest of the API even though some pieces of its code were completely identical to Random.
Therefore, the main goals of the new RandomGenerator API are:
- Ensure easier interchangeably of different algorithms
- Enable better support for stream-based programming
- Eliminate code duplication in existing classes
- Preserve existing behavior of the old Random API
3.3. New Interfaces
The new root interface RandomGenerator provides a uniform API for all existing and new generators.
It defines methods for returning randomly chosen values of different types, as well as streams of randomly chosen values.
The new API provides additional four new specialized generator interfaces:
- SplitableGenerator enables creating a new generator as a descendent of the current one
- JumpableGenerator allows jumping ahead a moderate number of draws
- LeapableGenerator allows jumping ahead a large number of draws
- ArbitrarilyJumpableGenerator adds jump distance to LeapableGenerator
4. RandomGeneratorFactory
A factory class for generating multiple random number generators of a specific algorithm is available in the new API.
4.1. Find All
The RandomGeneratorFactory method all produces a non-empty stream of all available generator factories.
We may use it to print all registered generator factories and check the properties of their algorithm:
RandomGeneratorFactory.all()
.sorted(Comparator.comparing(RandomGeneratorFactory::name))
.forEach(factory -> System.out.println(String.format("%s\t%s\t%s\t%s",
factory.group(),
factory.name(),
factory.isJumpable(),
factory.isSplittable())));
Availability of factories is determined by locating implementations of the RandomGenerator interface via the service provider API.
4.2. Find by Property
We can also make use of the all method to query factories by properties of the random number generator algorithm:
RandomGeneratorFactory.all()
.filter(RandomGeneratorFactory::isJumpable)
.findAny()
.map(RandomGeneratorFactory::create)
.orElseThrow(() -> new RuntimeException("Error creating a generator"));
Therefore, using the Stream API, we can find a factory that fulfills our requirements and then use it to create a generator.
5. RandomGenerator Selection
In addition to the updated API design, several new algorithms have been implemented, and more are likely to be added in the future.
5.1. Select Default
In most cases, we don’t have specific generator requirements. Thus, we can fetch the default generator directly from the RandomGenerator interface.
This is the new recommended approach in Java 17, as an alternative to creating instances of Random:
RandomGenerator generator = RandomGenerator.getDefault();
The getDefault method currently selects the L32X64MixRandom generator.
However, algorithms can change over time. Therefore, there’s no guarantee that this method will continue to return this algorithm in future releases.
5.2. Select Specific
On the other hand, when we do have specific generator requirements, we can retrieve a specific generator using the of method:
RandomGenerator generator = RandomGenerator.of("L128X256MixRandom");
This method requires the name of the random number generator to be passed as a parameter.
It will throw an IllegalArgumentException if the named algorithm is not found.
6. Thread Safety
Most of the new generator implementations are not thread-safe. However, both Random and SecureRandom still are.
Thus, in multithreaded environments, we can choose to either:
- Share an instance of a thread-safe generator
- Split a new instance from a local source before a new thread is started
We can achieve the second case using a SplittableGenerator:
List<Integer> numbers = Collections.synchronizedList(new ArrayList<>());
ExecutorService executorService = Executors.newCachedThreadPool();
RandomGenerator.SplittableGenerator sourceGenerator = RandomGeneratorFactory
.<RandomGenerator.SplittableGenerator>of("L128X256MixRandom")
.create();
sourceGenerator.splits(20).forEach((splitGenerator) -> {
executorService.submit(() -> {
numbers.add(splitGenerator.nextInt(10));
});
})
This way, we ensure that our generator instances get initialized in a way that doesn’t result in identical streams of numbers.
7. Performance
Let’s run a simple performance test for all the available generator implementations in Java 17.
We’ll test the generators on the same method generating four different types of random numbers:
private static void generateRandomNumbers(RandomGenerator generator) {
generator.nextLong();
generator.nextInt();
generator.nextFloat();
generator.nextDouble();
}
Let’s look at the benchmark results:
Algorithm
Mode
Score
Error
Units
L128X1024MixRandom
avgt
95,637
±3,274
ns/op
L128X128MixRandom
avgt
57,899
±2,162
ns/op
L128X256MixRandom
avgt
66,095
±3,260
ns/op
L32X64MixRandom
avgt
35,717
±1,737
ns/op
L64X1024MixRandom
avgt
73,690
±4,967
ns/op
L64X128MixRandom
avgt
35,261
±1,985
ns/op
L64X128StarStarRandom
avgt
34,054
±0,314
ns/op
L64X256MixRandom
avgt
36,238
±0,090
ns/op
Random
avgt
111,369
±0,329
ns/op
SecureRandom
avgt
9,457,881
±45,574
ns/op
SplittableRandom
avgt
27,753
±0,526
ns/op
Xoroshiro128PlusPlus
avgt
31,825
±1,863
ns/op
Xoshiro256PlusPlus
avgt
33,327
±0,555
ns/op
SecureRandom is the slowest generator, but this is because it’s the only cryptographically strong generator.
As they don’t have to be thread-safe, the new generator implementations perform faster compared to Random.
8. Conclusion
In this article, we explored updates in the API for random number generation, a new feature in Java SE 17.
We learned the differences between the old and the new API. Including the new API design, interfaces, and implementations that were introduced.
In the examples, we saw how to find a suitable generator algorithm using the RandomGeneratorFactory. We also saw how to select an algorithm based on its name or property.
Finally, we looked at thread safety and performance of the old and new generator implementations.
As always, the complete source code is available over on GitHub.