ThreadLocal, ThreadLocalRandom

Ebben a leckében általánosságban a java.lang.ThreadLocal<> osztállyal való munkáról és annak többszálú környezetben való használatáról fogunk beszélni.

A ThreadLocal osztály változók tárolására szolgál. Ennek az osztálynak az a megkülönböztető jellemzője, hogy minden egyes, ezt használó szálhoz megőrzi egy érték külön független másolatát.

Az osztály működésébe mélyebben beleásva elképzelhetünk egy olyan Map-et , amely a szálakat olyan értékekre képezi le, amelyekből az aktuális szál veszi a megfelelő értéket, amikor használnia kell.

ThreadLocal osztálykonstruktor

Mód

felkészülni()

Írjunk egy példát, ahol két számlálót hozunk létre. Az első, egy közönséges változó, a szálak számának számlálására szolgál. A másodikat egy ThreadLocal- ba csomagoljuk . És meglátjuk, hogyan működnek együtt. Először írjunk egy ThreadDemo osztályt, amely örökli a Runnable-t , és tartalmazza az adatainkat, valamint a minden szempontból fontos run() metódust. Hozzáadunk egy módszert a számlálók képernyőn történő megjelenítéséhez:

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

Osztályunk minden egyes futásával növeljük aszámlálóváltozó hívja a get() metódust, hogy adatokat kapjon a ThreadLocal változóból. Ha az új szálban nincs adat, akkor 0-ra állítjuk. Ha van adat, növeljük eggyel. És írjuk le a fő módszerünket:

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

}

Osztályunkat futtatva azt látjuk, hogy a ThreadLocal változó ugyanaz marad, függetlenül attól, hogy melyik szál éri el, de a szálak száma nő.

eltávolítás()

Az eltávolítási módszer működésének megértéséhez csak kissé módosítjuk a kódot a ThreadDemo osztályban:

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

Ebben a kódban, ha a szálszámláló páros szám, akkor a ThreadLocal változónkban a remove() metódust hívjuk meg . Eredmény:

És itt könnyen láthatjuk, hogy a második szál ThreadLocal változója null .

ThreadLocal.withInitial()

Ez a módszer létrehoz egy szál helyi változót.

A ThreadDemo osztály megvalósítása :

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

És megnézhetjük a kódunk eredményét:

Miért használjunk ilyen változókat?

A ThreadLocal absztrakciót biztosít a helyi változók felett a java.lang.Thread végrehajtási szálhoz képest.

A ThreadLocal változók abban különböznek a hagyományos változóktól, hogy minden szálnak megvan a saját, egyedileg inicializált változata, amely a get() és set() metódusokon keresztül érhető el.

Minden szálhoz, azaz a Thread osztály példányához tartozik ThreadLocal változók térképe . A térkép kulcsai a ThreadLocal objektumokra, az értékek pedig a „megszerzett” ThreadLocal változókra hivatkoznak .

Miért nem alkalmas a Random osztály véletlen számok generálására többszálú alkalmazásokban?

A Random osztályt használjuk a véletlen számok meghatározásához. De ugyanilyen jól működik többszálú környezetben is? Ami azt illeti, nem. A Random nem alkalmas többszálú környezetekhez, mert ha több szál egyszerre ér el egy osztályt, a teljesítmény csökken.

A probléma megoldására a JDK 7 bevezette a java.util.concurrent.ThreadLocalRandom osztályt, amely véletlen számokat generál többszálú környezetben. Két osztályból áll: ThreadLocal és Random .

Az egyik szál által kapott véletlen számok függetlenek a többi száltól, de a java.util.Random globálisan véletlen számokat biztosít. Ezenkívül, a Random -tól eltérően , a ThreadLocalRandom nem támogatja az explicit vetést. Ehelyett felülírja a Random -ból örökölt setSeed() metódust , így hívásakor mindig UnsupportedOperationException- t dob.

Nézzük meg a ThreadLocalRandom osztály metódusait:

Véletlen számok lekérése a ThreadLocalRandom.current() segítségével

A ThreadLocalRandom a ThreadLocal és a Random osztályok kombinációja. Jobb teljesítményt ér el többszálú környezetben, egyszerűen elkerülve a Random osztály példányaihoz való egyidejű hozzáférést.

Valósítsunk meg egy példát, amely több szálat tartalmaz, és nézzük meg, hogyan működik az alkalmazásunk a ThreadLocalRandom osztállyal:

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

Programunk eredménye:

És most változtassuk meg a RandomNumbers osztályunkat, és használjuk a Random-ot benne:

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

Összefoglalva és megismételve a Random és a ThreadLocalRandom osztályok közötti különbségeket: