ThreadLocal, ThreadLocalRandom

I denne leksjonen snakker vi generelt om å jobbe med java.lang.ThreadLocal<>- klassen og hvordan du bruker den i et flertrådsmiljø.

ThreadLocal - klassen brukes til å lagre variabler. Et særtrekk ved denne klassen er at den beholder en separat uavhengig kopi av en verdi for hver tråd som bruker den.

Når vi dykker dypere inn i klassens drift, kan vi forestille oss et kart som kartlegger tråder til verdier, hvorfra den gjeldende tråden tar den riktige verdien når den skal bruke den.

ThreadLocal klassekonstruktør

Metoder

klar()

La oss skrive et eksempel hvor vi lager to tellere. Den første, en ordinær variabel, vil være for å telle antall tråder. Den andre vil vi pakke inn i en ThreadLocal . Og vi får se hvordan de fungerer sammen. Først, la oss skrive en ThreadDemo- klasse som arver Runnable og inneholder dataene våre og den all-important run()- metoden. Vi legger også til en metode for å vise tellerne på skjermen:

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

For hvert løp i klassen vår øker vidiskvariabel kaller get() -metoden for å hente data fra ThreadLocal- variabelen. Hvis den nye tråden ikke har noen data, vil vi sette den til 0. Hvis det er data, vil vi øke den med én. Og la oss skrive hovedmetoden vår :

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 kjører klassen vår, ser vi at ThreadLocal- variabelen forblir den samme uavhengig av tråden som får tilgang til den, men antallet tråder vokser.

fjerne()

For å forstå hvordan fjerningsmetoden fungerer, vil vi bare endre koden litt i ThreadDemo -klassen:

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

I denne koden, hvis trådtelleren er et partall, vil vi kalle remove()- metoden på vår ThreadLocal- variabel. Resultat:

Og her ser vi lett at ThreadLocal- variabelen i den andre tråden er null .

ThreadLocal.withInitial()

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

Og vi kan se på resultatet av koden vår:

Hvorfor skal vi bruke slike variabler?

ThreadLocal gir en abstraksjon over lokale variabler i forhold til utførelsestråden java.lang.Thread .

ThreadLocal- variabler skiller seg fra vanlige ved at hver tråd har sin egen, individuelt initialiserte forekomst av variabelen, som er tilgjengelig viametodene get() og set() .

Hver tråd, dvs. forekomst av Thread -klassen, har et kart over ThreadLocal- variabler knyttet til seg. Kartets nøkler er referanser til ThreadLocal- objekter, og verdiene er referanser til "ervervede" ThreadLocal -variabler.

Hvorfor er ikke Random-klassen egnet for å generere tilfeldige tall i flertrådede applikasjoner?

Vi bruker Random- klassen for å få tilfeldige tall. Men fungerer det like bra i et flertrådsmiljø? Faktisk nei. Tilfeldig er ikke egnet for flertrådede miljøer, fordi når flere tråder får tilgang til en klasse samtidig, blir ytelsen dårligere.

For å løse dette problemet introduserte JDK 7 klassen java.util.concurrent.ThreadLocalRandom for å generere tilfeldige tall i et flertrådsmiljø. Den består av to klasser: ThreadLocal og Random .

De tilfeldige tallene som mottas av en tråd er uavhengige av andre tråder, men java.util.Random gir globalt tilfeldige tall. I motsetning til Random støtter ikke ThreadLocalRandom eksplisitt seeding. I stedet overstyrer den setSeed() -metoden som er arvet fra Random , slik at den alltid kaster en UnsupportedOperationException når den kalles.

La oss se på metodene til ThreadLocalRandom -klassen:

Få tilfeldige tall ved å bruke ThreadLocalRandom.current()

ThreadLocalRandom er en kombinasjon av ThreadLocal og Random -klassene. Den oppnår bedre ytelse i et flertrådsmiljø ved ganske enkelt å unngå samtidig tilgang til forekomster av Random- klassen.

La oss implementere et eksempel som involverer flere tråder og se at applikasjonen vår gjør det med ThreadLocalRandom -klassen:

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 programmet vårt:

Og la oss nå endre RandomNumbers- klassen og bruke Random i den:

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

For å oppsummere og gjenta forskjellene mellom Random og ThreadLocalRandom- klassene: