WątekLokalny, WątekLokalnyLosowy

Podczas tego wykładu omówimy ogólnie pracę z klasą java.lang.ThreadLocal<> oraz sposób pracy z nią w środowisku wielowątkowym.

Klasa ThreadLocal służy do przechowywania zmiennych. Osobliwością tej klasy jest to, że przechowuje oddzielną, niezależną kopię wartości dla każdego wątku, który z niej korzysta.

Jeśli rozłożymy bardziej szczegółowo sposób działania klasy, możemy sobie wyobrazić mapę formularza strumień→wartość, która, gdy jest używana, odnosi się do wartości bieżącego strumienia.

Konstruktor klasy ThreadLocal

Metody

przygotować się()

Napiszmy przykład, w którym tworzymy dwa liczniki. Pierwsza, normalna zmienna będzie do zliczania liczby wątków, a drugą zawiniemy w ThreadLocal i zobaczymy, jak ze sobą współpracują. Najpierw napiszmy klasę ThreadDemo odziedziczoną po Runnable , w której będą przechowywane nasze dane i główną metodę run() oraz dodajmy metodę wyświetlania liczników na ekranie:

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

Z każdym uruchomieniem naszej klasy będziemy zwiększać zmiennąlada, a dodatkowo wywołamy metodę get() w celu pobrania danych ze zmiennej ThreadLocal . Jeśli w nowym strumieniu nie ma danych, to ustawimy go na 0, a jeśli są dane, zwiększymy go o jeden. I napiszmy naszą główną klasę :

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

}

W wyniku pracy naszej klasy widzimy, że zmienna ThreadLocal pozostaje taka sama niezależnie od wątku, który uzyskuje do niej dostęp, ale liczba wątków rośnie.

usunąć()

Aby zrozumieć, jak działa metoda usuwania , zmienimy nieco kod klasy ThreadDemo :

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

W tym kodzie ustalimy, że jeśli ten licznik wątków jest liczbą parzystą, wywołamy metodę remove() na naszej zmiennej ThreadLocal . Wynik kodu:

I tutaj możemy łatwo zobaczyć, że zmienna ThreadLocal w drugim wątku ma wartość null .

ThreadLocal.withInitial()

Ta metoda tworzy zmienną lokalną wątku.

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

I możemy spojrzeć na wynik naszego kodu:

Dlaczego powinniśmy używać takich zmiennych?

ThreadLocal zapewnia abstrakcję nad zmiennymi lokalnymi w odniesieniu do wątku wykonania java.lang.Thread .

Zmienne ThreadLocal różnią się od zwykłych tym, że każdy wątek ma swoją własną, indywidualnie inicjowaną instancję zmiennej, do której uzyskuje dostęp za pomocą metod get() lub set() .

Z każdym wątkiem, czyli instancją klasy Thread , jest powiązana tabela zmiennych ThreadLocal . Klucze tabeli to odniesienia do obiektów klasy ThreadLocal , a wartości to odniesienia do obiektów „przechwyconych” przez zmienne ThreadLocal.

Dlaczego generowanie liczb losowych przez Random nie jest odpowiednie dla aplikacji wielowątkowych?

Używamy klasy Random , aby uzyskać losową liczbę. Ale czy nadal będzie działać równie dobrze w środowisku wielowątkowym? Nie bardzo. Random nie nadaje się do wielowątkowości, ponieważ gdy wiele wątków uzyskuje dostęp do klasy w tym samym czasie, staje się ona mniej wydajna.

W tym celu JDK 7 wprowadził klasę java.util.concurrent.ThreadLocalRandom do generowania liczb losowych w środowisku wielowątkowym. Składa się z dwóch klas: ThreadLocal i Random .

Losowa liczba otrzymana przez jeden wątek jest niezależna od innego wątku, podczas gdy java.util.Random zapewnia globalne liczby losowe. Ponadto, w przeciwieństwie do Random , ThreadLocalRandom nie obsługuje jawnego inicjowania. Zamiast tego zastępuje metodę setSeed() odziedziczoną z Random , aby zawsze zgłaszać wyjątek UnsupportedOperationException po wywołaniu.

Rzućmy okiem na metody ThreadLocalRandom :

Pobieranie losowych danych za pomocą ThreadLocalRandom.current()

ThreadLocalRandom to połączenie klas ThreadLocal i Random . W ten sposób osiąga lepszą wydajność w środowisku wielowątkowym, po prostu unikając współbieżnego dostępu do instancji Random .

Zaimplementujmy przykład dla wielu wątków i zobaczmy, jaki będzie wynik naszej aplikacji z klasą 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));
    }
}

Wynik naszego programu:

A teraz zmieńmy naszą klasę RandomNumbers i użyjmy w niej Random :

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

Podsumowując i powtarzając różnice między klasą Random a ThreadLocalRandom :