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
// 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
// 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:
SubprocesoLocalAleatorio | SeguroAleatorio |
ThreadLocalRandom es una combinación de las clases ThreadLocal y Random | La clase SecureRandom proporciona un generador de números aleatorios criptográficamente fuerte |
Está aislado del subproceso actual. |
Su sintaxis es -: clase pública SecureRandom extiende Random |
tiene un mejor rendimiento en un entorno multiproceso | Las implementaciones de SecureRandom tienen la forma de un generador de números pseudoaleatorios |
ThreadLocalRandom no admite la configuración explícita de la semilla. En cambio | Esta clase no funciona en un compilador en línea. |
Se introduce a partir de jdk 1.7 en adelante. | La clase SecureRandom es una subclase de la clase Random. |
Publicación traducida automáticamente
Artículo escrito por ManasiKirloskar y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA