ThreadLocal, ThreadLocalRandom

In questa lezione parleremo in generale dell'utilizzo della classe java.lang.ThreadLocal<> e di come utilizzarla in un ambiente multithread.

La classe ThreadLocal viene utilizzata per memorizzare le variabili. Una caratteristica distintiva di questa classe è che mantiene una copia indipendente separata di un valore per ogni thread che lo utilizza.

Approfondendo il funzionamento della classe, possiamo immaginare una mappa che associa i thread ai valori, da cui il thread corrente prende il valore appropriato quando ha bisogno di usarlo.

Costruttore di classe ThreadLocal

Metodi

preparatevi()

Scriviamo un esempio in cui creiamo due contatori. La prima, una variabile ordinaria, servirà per contare il numero di thread. Il secondo lo avvolgeremo in un ThreadLocal . E vedremo come lavorano insieme. Innanzitutto, scriviamo una classe ThreadDemo che erediti Runnable e contenga i nostri dati e l'importantissimo metodo run() . Aggiungeremo anche un metodo per visualizzare i contatori sullo schermo:

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 ogni corsa della nostra classe, aumentiamo ilcontatorevariable chiama il metodo get() per ottenere i dati dalla variabile ThreadLocal . Se il nuovo thread non ha dati, lo imposteremo su 0. Se ci sono dati, lo aumenteremo di uno. E scriviamo il nostro metodo principale :

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();

}

Eseguendo la nostra classe, vediamo che la variabile ThreadLocal rimane la stessa indipendentemente dal thread che vi accede, ma il numero di thread cresce.

rimuovere()

Per capire come funziona il metodo remove , cambieremo solo leggermente il codice nella classe ThreadDemo :

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

In questo codice, se il contatore di thread è un numero pari, chiameremo il metodo remove() sulla nostra variabile ThreadLocal . Risultato:

E qui vediamo facilmente che la variabile ThreadLocal nel secondo thread è null .

ThreadLocal.withInitial()

Questo metodo crea una variabile locale del thread.

Implementazione della classe 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());
    }
}

E possiamo guardare il risultato del nostro codice:

Perché dovremmo usare tali variabili?

ThreadLocal fornisce un'astrazione sulle variabili locali in relazione al thread di esecuzione java.lang.Thread .

Le variabili ThreadLocal differiscono da quelle ordinarie in quanto ogni thread ha la propria istanza della variabile inizializzata individualmente, a cui si accede tramite imetodi get() e set() .

Ad ogni thread, cioè istanza della classe Thread , è associata una mappa di variabili ThreadLocal . Le chiavi della mappa sono riferimenti a oggetti ThreadLocal e i valori sono riferimenti a variabili ThreadLocal "acquisite" .

Perché la classe Random non è adatta per generare numeri casuali in applicazioni multithread?

Usiamo la classe Random per ottenere numeri casuali. Ma funziona altrettanto bene in un ambiente multithread? In realtà no. Random non è adatto per ambienti multithread, perché quando più thread accedono a una classe contemporaneamente, le prestazioni ne risentono.

Per risolvere questo problema, JDK 7 ha introdotto la classe java.util.concurrent.ThreadLocalRandom per generare numeri casuali in un ambiente multithread. Consiste di due classi: ThreadLocal e Random .

I numeri casuali ricevuti da un thread sono indipendenti da altri thread, ma java.util.Random fornisce numeri casuali globali. Inoltre, a differenza di Random , ThreadLocalRandom non supporta il seeding esplicito. Al contrario, sovrascrive il metodo setSeed() ereditato da Random , in modo che generi sempre un'eccezione UnsupportedOperationException quando viene chiamato.

Diamo un'occhiata ai metodi della classe ThreadLocalRandom :

Ottenere numeri casuali usando ThreadLocalRandom.current()

ThreadLocalRandom è una combinazione delle classi ThreadLocal e Random . Raggiunge prestazioni migliori in un ambiente multithread semplicemente evitando qualsiasi accesso simultaneo alle istanze della classe Random .

Implementiamo un esempio che coinvolge più thread e vediamo la nostra applicazione con la classe 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));
    }
}

Risultato del nostro programma:

E ora cambiamo la nostra classe RandomNumbers e usiamo Random in essa:

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

Per riassumere e ribadire le differenze tra le classi Random e ThreadLocalRandom :