Random Number Generators in Java 17

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:

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.