Clase ThreadLocalRandom vs SecureRandom en Java

La clase ThreadLocalRandom del paquete java.util es un generador de números aleatorios que genera números aleatorios aislados del hilo actual. Es una subclase de la clase Random . Se inicializa con un valor inicial generado internamente que no se puede modificar. La vista de clase es la siguiente: 

--> java.util Package
    --> ThreadLocalRandom Class   

ThreadLocalRandom sería útil en aplicaciones donde varios subprocesos se ejecutan simultáneamente, dado que la generación de números aleatorios permanece aislada, los subprocesos no tienen que competir por instancias compartidas (como en el caso de las instancias de clase Random) y ofrece un mejor rendimiento y una sobrecarga más baja. Sin embargo, no es criptográficamente seguro. Aquí es donde entra en juego SecureRandom, que se analiza más adelante en esta publicación.

Sintaxis:

public class ThreadLocalRandom extends Random

El uso de ThreadLocalRandom es generalmente de la forma:

ThreadLocalRandom.current().nextX(...) {where X = Int, Long, Double etc}

Implementación:

Supongamos que se crean dos subprocesos en el método main(). Ahora dentro del método run() llamamos a ThreadLocalRandom.current.nextInt(). El método run() de la clase Thread es donde se escribe la parte ejecutable de cualquier hilo. Cuando el subproceso se inicia con el método start() , run() se llama intrínsecamente. Los subprocesos se ejecutan y generan valores enteros aleatorios cuando llamamos al método nextInt() de ThreadLocalRandom.

Pueden generar el mismo número con el mismo valor inicial, pero la generación aún está aislada, es decir, no hay competencia por el espacio, como en el caso de los objetos compartidos.

Ejemplo:

// Java Program to Illustrate ThreadLocalRandom Class
 
// Importing required classes
import java.util.concurrent.ThreadLocalRandom;
 
// Main class
public class ThreadLocalRandomNumbers extends Thread {
 
    // Method 1
    // The run() method of the Thread class
    // Must be defined by every class that extends it
    public void run()
    {
        // Try method to check for exceptions
        try {
            // Call the ThreadLocalRandom
            int r = ThreadLocalRandom.current().nextInt(20);
 
            // Print the generated number r
            System.out.println(
                "Thread " + Thread.currentThread().getId()
                + " generated " + r);
        }
 
        // Catch block to handle the exceptions
        catch (Exception e) {
            System.out.println("Exception");
        }
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
        // Create 2 threads
        ThreadLocalRandomNumbers t1
            = new ThreadLocalRandomNumbers();
        ThreadLocalRandomNumbers t2
            = new ThreadLocalRandomNumbers();
 
        // Start the threads using the start() method
        t1.start();
        t2.start();
    }
}

Thread 11 generated 2
Thread 12 generated 10

La clase SecureRandom del paquete java.util es un generador de números aleatorios criptográficamente seguro. Es una subclase de la clase Random . Un número aleatorio criptográficamente seguro cumple con las Pruebas de generador de números aleatorios estadísticos especificadas en FIPS 140-2, Requisitos de seguridad para módulos criptográficos, sección 4.9.1. SecureRandom produce una salida no determinista y este es un requisito necesario para tales módulos.

Sintaxis:

public class SecureRandom extends Random

Tomemos un ejemplo, en el código que se proporciona a continuación, creamos una instancia de la clase SecureRandom e inicializamos el valor semilla. A continuación, usamos un bucle for para llamar al método nextInt() 5 veces. El método nextInt() usa el valor semilla para generar números enteros desde 0 hasta semilla-1 (inclusive). Todo esto se hace dentro de un bloque try-catch, ya que arroja una excepción cuando se usa en cualquier compilador en línea (lea la nota que se proporciona a continuación).

Ejemplo 

// Java Program to Illustrate SecureRandom Class
 
// Importing class from java.security package
import java.security.SecureRandom;
 
// Main class
public class SecureRandomNumbers {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Try block to check for exceptions
        try {
 
            // Creating an instance of SecureRandom
            // using the default constructor
            SecureRandom r = new SecureRandom();
 
            // Initializing a seed value
            int seed = 100;
 
            // Display command
            System.out.println("Random Numbers");
 
            for (int i = 0; i < 5; i++) {
 
                // Generating random numbers between 0 and
                // seed-1 inclusive using nextInt() method
                System.out.print(r.nextInt(seed) + " ");
            }
        }
 
        // Catch block to handle the exceptions
        catch (Exception e) {
 
            // Display message when exception occurs
            System.out.print("Exception");
        }
    }
}

Random Numbers
Exception

Producción

Nota: la clase SecureRandom no funcionará en un compilador en línea debido a su naturaleza criptográficamente segura. Sin embargo, si usa un IDE en su sistema, podrá obtener el resultado que se muestra en la imagen de arriba.

Veamos las diferencias en una forma tabular como se muestra a continuación de la siguiente manera: