ThreadLocal, ThreadLocalRandom

I den här lektionen kommer vi att prata allmänt om att arbeta med klassen java.lang.ThreadLocal<> och hur man använder den i en flertrådsmiljö.

Klassen ThreadLocal används för att lagra variabler. En utmärkande egenskap för denna klass är att den behåller en separat oberoende kopia av ett värde för varje tråd som använder den.

När vi fördjupar oss i klassens funktion kan vi föreställa oss en karta som mappar trådar till värden, från vilken den aktuella tråden tar rätt värde när den behöver använda den.

ThreadLocal klasskonstruktör

Metoder

get() & set()

Låt oss skriva ett exempel där vi skapar två räknare. Den första, en vanlig variabel, kommer att vara för att räkna antalet trådar. Den andra kommer vi att slå in i en ThreadLocal . Och vi får se hur de fungerar tillsammans. Låt oss först skriva en ThreadDemo- klass som ärver Runnable och som innehåller vår data och den all-important run()- metoden. Vi kommer också att lägga till en metod för att visa räknarna på skärmen:

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

Med varje körning i vår klass ökar vidiskenvariabel anropar metoden get() för att hämta data från variabeln ThreadLocal . Om den nya tråden inte har några data kommer vi att sätta den till 0. Om det finns data kommer vi att öka den med en. Och låt oss skriva vår huvudmetod :

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

}

När vi kör vår klass ser vi att ThreadLocal -variabeln förblir densamma oavsett vilken tråd som kommer åt den, men antalet trådar växer.

avlägsna()

För att förstå hur borttagningsmetoden fungerar kommer vi bara att ändra koden något i klassen ThreadDemo :

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

I den här koden, om trådräknaren är ett jämnt tal, anropar vi metoden remove() på vår ThreadLocal -variabel. Resultat:

Och här ser vi lätt att ThreadLocal -variabeln i den andra tråden är null .

ThreadLocal.withInitial()

Denna metod skapar en trådlokal variabel.

Implementering av ThreadDemo -klassen:

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

Och vi kan titta på resultatet av vår kod:

Varför ska vi använda sådana variabler?

ThreadLocal tillhandahåller en abstraktion över lokala variabler i relation till exekveringstråden java.lang.Thread .

ThreadLocal- variabler skiljer sig från vanliga genom att varje tråd har sin egen, individuellt initierade instans av variabeln, som nås viametoderna get() och set() .

Varje tråd, dvs instans av klassen Thread , har en karta över ThreadLocal -variabler kopplade till sig. Kartans nycklar är referenser till ThreadLocal- objekt, och värdena är referenser till "förvärvade" ThreadLocal -variabler.

Varför är klassen Random inte lämplig för att generera slumptal i flertrådade applikationer?

Vi använder klassen Random för att få slumptal. Men fungerar det lika bra i en multitrådad miljö? Faktiskt nej. Random är inte lämpligt för flertrådade miljöer, för när flera trådar får åtkomst till en klass samtidigt blir prestandan lidande.

För att lösa detta problem introducerade JDK 7 klassen java.util.concurrent.ThreadLocalRandom för att generera slumpmässiga tal i en flertrådsmiljö. Den består av två klasser: ThreadLocal och Random .

De slumptal som tas emot av en tråd är oberoende av andra trådar, men java.util.Random tillhandahåller globalt slumptal. Till skillnad från Random stöder inte ThreadLocalRandom explicit sådd . Istället åsidosätter den metoden setSeed() som ärvts från Random , så att den alltid kastar en UnsupportedOperationException när den anropas.

Låt oss titta på metoderna för klassen ThreadLocalRandom :

Få slumptal med ThreadLocalRandom.current()

ThreadLocalRandom är en kombination avklasserna ThreadLocal och Random . Den uppnår bättre prestanda i en flertrådad miljö genom att helt enkelt undvika all samtidig åtkomst till instanser avklassen Random .

Låt oss implementera ett exempel som involverar flera trådar och se vår applikation gör med klassen 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));
    }
}

Resultatet av vårt program:

Och låt oss nu ändra vår RandomNumbers- klass och använda Random i den:

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

För att sammanfatta och upprepa skillnaderna mellan klasserna Random och ThreadLocalRandom :