Subproceso Local, Subproceso Local Aleatorio

En esta lección, hablaremos en general sobre cómo trabajar con la clase java.lang.ThreadLocal<> y cómo usarla en un entorno multihilo.

La clase ThreadLocal se utiliza para almacenar variables. Una característica distintiva de esta clase es que mantiene una copia independiente separada de un valor para cada subproceso que lo usa.

Profundizando en el funcionamiento de la clase, podemos imaginar un Mapa que mapea hilos a valores, de los cuales el hilo actual toma el valor apropiado cuando necesita usarlo.

Constructor de clase ThreadLocal

Métodos

obtener () y establecer ()

Escribamos un ejemplo donde creamos dos contadores. La primera, una variable ordinaria, será para contar el número de hilos. El segundo lo envolveremos en un ThreadLocal . Y veremos cómo trabajan juntos. Primero, escribamos una clase ThreadDemo que herede Runnable y contenga nuestros datos y el importantísimo método run() . También agregaremos un método para mostrar los contadores en la pantalla:

class ThreadDemo implements Runnable {

    int counter;
    ThreadLocal<Integer> threadLocalCounter = new ThreadLocal<>();

    public void run() {
        counter++;

        if(threadLocalCounter.get() != null) {
            threadLocalCounter.set(threadLocalCounter.get() + 1);
        } else {
            threadLocalCounter.set(0);
        }
        printCounters();
    }

    public void printCounters(){
        System.out.println("Counter: " + counter);
        System.out.println("threadLocalCounter: " + threadLocalCounter.get());
    }
}

Con cada carrera de nuestra clase, aumentamos el counter llamando al método get() para obtener datos de la variable ThreadLocal . Si el nuevo hilo no tiene datos, lo estableceremos en 0. Si hay datos, los aumentaremos en uno. Y escribamos nuestro método principal :

public static void main(String[] args) {
    ThreadDemo threadDemo = new ThreadDemo();

    Thread t1 = new Thread(threadDemo);
    Thread t2 = new Thread(threadDemo);
    Thread t3 = new Thread(threadDemo);

    t1.start();
    t2.start();
    t3.start();

}

Al ejecutar nuestra clase, vemos que la variable ThreadLocal permanece igual independientemente del subproceso que accede a ella, pero el número de subprocesos crece.

eliminar()

Para comprender cómo funciona el método de eliminación , cambiaremos ligeramente el código en la clase ThreadDemo :

if(threadLocalCounter.get() != null) {
      threadLocalCounter.set(threadLocalCounter.get() + 1);
  } else {
      if (counter % 2 == 0) {
          threadLocalCounter.remove();
      } else {
          threadLocalCounter.set(0);
      }
  }

En este código, si el contador de subprocesos es un número par, llamaremos al método remove() en nuestra variable ThreadLocal . Resultado:

Y aquí vemos fácilmente que la variable ThreadLocal en el segundo hilo es nula .

ThreadLocal.withInitial()

Este método crea una variable local de hilo.

Implementación de la clase ThreadDemo :

class ThreadDemo implements Runnable {

    int counter;
    ThreadLocal<Integer> threadLocalCounter = ThreadLocal.withInitial(() -> 1);

    public void run() {
        counter++;
        printCounters();
    }

    public void printCounters(){
        System.out.println("Counter: " + counter);
        System.out.println("threadLocalCounter: " + threadLocalCounter.get());
    }
}

Y podemos ver el resultado de nuestro código:

¿Por qué debemos usar tales variables?

ThreadLocal proporciona una abstracción sobre las variables locales en relación con el hilo de ejecución java.lang.Thread .

Las variables ThreadLocal difieren de las ordinarias en que cada hilo tiene su propia instancia inicializada individualmente de la variable, a la que se accede a través de losmétodos get() y set() .

Cada subproceso, es decir, instancia de la clase Subproceso , tiene un mapa de variables ThreadLocal asociado con él. Las claves del mapa son referencias a objetos ThreadLocal y los valores son referencias a variables ThreadLocal "adquiridas" .

¿Por qué la clase Random no es adecuada para generar números aleatorios en aplicaciones de subprocesos múltiples?

Usamos la clase Random para obtener números aleatorios. Pero, ¿funciona igual de bien en un entorno de subprocesos múltiples? En realidad no. Random no es adecuado para entornos de subprocesos múltiples, porque cuando varios subprocesos acceden a una clase al mismo tiempo, el rendimiento se ve afectado.

Para abordar este problema, JDK 7 introdujo la clase java.util.concurrent.ThreadLocalRandom para generar números aleatorios en un entorno multihilo. Consta de dos clases: ThreadLocal y Random .

Los números aleatorios recibidos por un subproceso son independientes de otros subprocesos, pero java.util.Random proporciona números aleatorios globales. Además, a diferencia de Random , ThreadLocalRandom no admite la propagación explícita. En su lugar, anula el método setSeed() heredado de Random , por lo que siempre arroja una UnsupportedOperationException cuando se le llama.

Veamos los métodos de la clase ThreadLocalRandom :

Obtener números aleatorios usando ThreadLocalRandom.current()

ThreadLocalRandom es una combinación de las clases ThreadLocal y Random . Logra un mejor rendimiento en un entorno de subprocesos múltiples simplemente evitando cualquier acceso simultáneo a instancias de la clase Random .

Implementemos un ejemplo que involucre varios subprocesos y veamos cómo funciona nuestra aplicación con la clase ThreadLocalRandom :

import java.util.concurrent.ThreadLocalRandom;

class RandomNumbers extends Thread {

    public void run() {
        try {
            int bound = 100;
            int result = ThreadLocalRandom.current().nextInt(bound);
            System.out.println("Thread " + Thread.currentThread().getId() + " generated " + result);
        }
        catch (Exception e) {
            System.out.println("Exception");
        }
    }

    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();

				for (int i = 0; i < 10; i++) {
            RandomNumbers randomNumbers = new RandomNumbers();
            randomNumbers.start();
        }

        long endTime = System.currentTimeMillis();

        System.out.println("Time taken: " + (endTime - startTime));
    }
}

Resultado de nuestro programa:

Y ahora cambiemos nuestra clase RandomNumbers y usemos Random en ella:

int result = new Random().nextInt(bound);

Para resumir y reiterar las diferencias entre las clases Random y ThreadLocalRandom :