Kiedy i jak powinienem używać zmiennej ThreadLocal?

Kiedy powinienem użyć ThreadLocalzmiennej?

Jak to jest używane?

Jednym z możliwych (i powszechnych) zastosowań jest posiadanie obiektu, który nie jest bezpieczny dla wątków, ale chcesz uniknąć synchronizowania dostępu do tego obiektu (patrzę na ciebie, SimpleDateFormat ). Zamiast tego nadaj każdemu wątkowi własną instancję obiektu.

Na przykład:

public class Foo
{
    // SimpleDateFormat is not thread-safe, so give one to each thread
    private static final ThreadLocal<SimpleDateFormat> formatter = new ThreadLocal<SimpleDateFormat>(){
        @Override
        protected SimpleDateFormat initialValue()
        {
            return new SimpleDateFormat("yyyyMMdd HHmm");
        }
    };

    public String formatIt(Date date)
    {
        return formatter.get().format(date);
    }
}

Dokumentacja .

Ponieważ a ThreadLocaljest odniesieniem do danych w danym obszarze Thread, możesz skończyć przeciekami klasy podczas używania ThreadLocals na serwerach aplikacji za pomocą pul wątków. Trzeba być bardzo ostrożnym czyszczenia żadnych ThreadLocaljesteś ty get()lub set()za pomocą ThreadLocal„s remove()metody.

Jeśli nie wyczyścisz po zakończeniu, wszelkie odwołania do klas załadowanych jako część wdrożonej aplikacji internetowej pozostaną na stałym stosie i nigdy nie zostaną usunięte. Ponowne wdrożenie / cofnięcie aplikacji internetowej nie wyczyści Threadodniesienia do klas aplikacji, ponieważ Threadnie jest to własność aplikacji internetowej. Każde kolejne wdrożenie spowoduje utworzenie nowej instancji klasy, która nigdy nie będzie zbierana w pamięci.

java.lang.OutOfMemoryError: PermGen spaceSkończysz z brakami pamięci z powodu i po pewnym googlingu prawdopodobnie po prostu wzrośnie -XX:MaxPermSizezamiast naprawiać błąd.

Jeśli napotkasz te problemy, możesz ustalić, który wątek i klasa zachowuje te referencje, korzystając z narzędzia Eclipse's Memory Analyzer i / lub postępując zgodnie z instrukcjami Franka Kieviet i działaniami następczymi .

Aktualizacja: Ponownie odkryłem wpis na blogu Alexa Vasseura, który pomógł mi wyśledzić niektóre ThreadLocalproblemy, które miałem.

Wiele frameworków używa ThreadLocals do utrzymywania kontekstu związanego z bieżącym wątkiem. Na przykład, gdy bieżąca transakcja jest przechowywana w ThreadLocal, nie musisz przekazywać jej jako parametru przy każdym wywołaniu metody, na wypadek, gdyby ktoś na stosie potrzebował do niej dostępu. Aplikacje internetowe mogą przechowywać informacje o bieżącym żądaniu i sesji w ThreadLocal, aby aplikacja miała do nich łatwy dostęp. Dzięki Guice możesz używać ThreadLocals podczas implementowania niestandardowych zakresów dla wstrzykiwanych obiektów (domyślnie zakresy serwletów Guice najprawdopodobniej również z nich korzystają).

ThreadLocals to jeden z rodzajów zmiennych globalnych (choć nieco mniej złych, ponieważ są ograniczone do jednego wątku), dlatego należy zachować ostrożność podczas ich używania, aby uniknąć niepożądanych efektów ubocznych i wycieków pamięci. Zaprojektuj swoje interfejsy API, aby wartości ThreadLocal były zawsze automatycznie usuwane, gdy nie są już potrzebne, i że nieprawidłowe użycie interfejsu API nie będzie możliwe (na przykład w ten sposób ). ThreadLocals może być użyty do czyszczenia kodu, a w niektórych rzadkich przypadkach są one jedynym sposobem, aby coś zadziałało (mój obecny projekt miał dwa takie przypadki; są one udokumentowane tutaj w „Static Fields and Global Variables”).

W Javie, jeśli masz układ odniesienia, który może różnić się w zależności od wątku, możesz przekazać ten układ do każdej metody, która go potrzebuje (lub może potrzebować), lub powiązać układ z wątkiem. Przekazywanie punktu odniesienia wszędzie może być wykonalne, jeśli wszystkie twoje metody muszą już przekazywać wspólną zmienną „kontekstową”.

Jeśli tak nie jest, możesz nie chcieć zaśmiecać podpisów metod dodatkowym parametrem. W świecie bez wątków można rozwiązać problem z odpowiednikiem zmiennej globalnej w języku Java. W słowie wątkowym odpowiednikiem zmiennej globalnej jest zmienna lokalna.

Jest bardzo dobry przykład w książce Java Concurrency in Practice . Tam, gdzie autor ( Joshua Bloch ) wyjaśnia, w jaki sposób ograniczanie wątków jest jednym z najprostszych sposobów na osiągnięcie bezpieczeństwa wątków, a ThreadLocal jest bardziej formalnym sposobem utrzymywania ograniczania wątków. Na koniec wyjaśnia również, w jaki sposób ludzie mogą go nadużywać, używając go jako zmiennych globalnych.

Skopiowałem tekst ze wspomnianej książki, ale brakuje kodu 3.10, ponieważ nie jest ważne, aby zrozumieć, gdzie powinien być używany ThreadLocal.

Zmienne lokalne wątków są często używane, aby zapobiec współużytkowaniu w projektach opartych na zmiennych Singletonach lub zmiennych globalnych. Na przykład aplikacja jednowątkowa może utrzymywać globalne połączenie z bazą danych inicjowane podczas uruchamiania, aby uniknąć konieczności przekazywania połączenia do każdej metody. Ponieważ połączenia JDBC mogą nie być bezpieczne dla wątków, aplikacja wielowątkowa korzystająca z połączenia globalnego bez dodatkowej koordynacji również nie jest bezpieczna dla wątków. Używając ThreadLocal do przechowywania połączenia JDBC, tak jak w ConnectionHolder na Listingu 3.10, każdy wątek będzie miał własne połączenie.

ThreadLocal jest szeroko stosowany we wdrażaniu struktur aplikacji. Na przykład kontenery J2EE kojarzą kontekst transakcji z wątkiem wykonawczym na czas trwania wywołania EJB. Można to łatwo zaimplementować za pomocą statycznego Lokalnego wątku przechowującego kontekst transakcji: gdy kod frameworka musi określić, która transakcja jest aktualnie wykonywana, pobiera kontekst transakcji z tego obiektu ThreadLocal. Jest to wygodne, ponieważ zmniejsza potrzebę przekazywania informacji kontekstu wykonania do każdej metody, ale łączy dowolny kod korzystający z tego mechanizmu ze strukturą.

Łatwo jest nadużywać ThreadLocal, traktując jego właściwość ograniczania wątków jako licencję na używanie zmiennych globalnych lub jako środek do tworzenia „ukrytych” argumentów metod. Podobnie jak zmienne globalne, zmienne lokalne wątków mogą niekorzystnie wpływać na możliwość ponownego użycia i wprowadzać ukryte sprzężenia między klasami, dlatego też należy ich używać ostrożnie.

Zasadniczo, gdy potrzebujesz wartości zmiennej zależnej od bieżącego wątku i nie jest wygodne dołączanie wartości do wątku w inny sposób (na przykład wątek podklasy).

Typowy przypadek ma miejsce, gdy jakiś inny framework utworzył wątek, w którym działa twój kod, np. Kontener serwletu, lub gdy bardziej sensowne jest użycie ThreadLocal, ponieważ twoja zmienna jest wtedy „w swoim logicznym miejscu” (zamiast zmiennej zwisające z podklasy Wątek lub na innej mapie mieszającej).

Na mojej stronie internetowej omówiłem kilka przykładów i przykładów użycia ThreadLocal, które mogą być również interesujące.

Niektóre osoby opowiadają się za użyciem ThreadLocal jako sposobu na dołączenie „ID wątku” do każdego wątku w pewnych współbieżnych algorytmach, w których potrzebny jest numer wątku (patrz np. Herlihy i Shavit). W takich przypadkach sprawdź, czy naprawdę dostajesz zasiłek!

1. ThreadLocal w Javie został wprowadzony w JDK 1.2, ale później został wygenerowany w JDK 1.5 w celu wprowadzenia bezpieczeństwa typu w zmiennej ThreadLocal.

2. ThreadLocal może być powiązany z zakresem wątku, cały kod wykonywany przez Thread ma dostęp do zmiennych ThreadLocal, ale dwa wątki nie widzą się nawzajem Zmienna ThreadLocal.

3. Każdy wątek zawiera wyłączną kopię zmiennej ThreadLocal, która kwalifikuje się do wyrzucania elementów bezużytecznych po zakończeniu lub śmierci wątku, normalnie lub z powodu wyjątku, biorąc pod uwagę, że zmienna ThreadLocal nie ma żadnych innych aktywnych odniesień.

4. Zmienne ThreadLocal w Javie są zwykle prywatnymi polami statycznymi w klasach i utrzymują swój stan w wątku.

Czytaj więcej: ThreadLocal w Javie - Przykładowy program i samouczek

Dokumentacja mówi bardzo dobrze: „każdy wątek, który uzyskuje dostęp do [zmiennej lokalnej wątku] (za pomocą metody get lub set) ma swoją własną, niezależnie inicjowaną kopię zmiennej”.

Używasz jednego, gdy każdy wątek musi mieć własną kopię czegoś. Domyślnie dane są dzielone między wątkami.

Serwer Webapp może przechowywać pulę wątków, a ThreadLocalvar powinien zostać usunięty przed odpowiedzią na klienta, dlatego bieżący wątek może zostać ponownie wykorzystany przy następnym żądaniu.

Dwa przypadki użycia, w których można zastosować zmienną Threadlocal -
1- Gdy mamy wymaganie skojarzenia stanu z wątkiem (np. Identyfikator użytkownika lub identyfikator transakcji). Zdarza się to zwykle w przypadku aplikacji internetowej, z którą każde żądanie kierowane do serwletu ma przypisany unikalny identyfikator transakcji.

// This class will provide a thread local variable which
// will provide a unique ID for each thread
class ThreadId {
    // Atomic integer containing the next thread ID to be assigned
    private static final AtomicInteger nextId = new AtomicInteger(0);

    // Thread local variable containing each thread's ID
    private static final ThreadLocal<Integer> threadId =
        ThreadLocal.<Integer>withInitial(()-> {return nextId.getAndIncrement();});

    // Returns the current thread's unique ID, assigning it if necessary
    public static int get() {
        return threadId.get();
    }
}

Zauważ, że tutaj metoda withInitial jest implementowana przy użyciu wyrażenia lambda.
2- Innym przypadkiem użycia jest sytuacja, gdy chcemy mieć instancję bezpieczną dla wątków i nie chcemy używać synchronizacji, ponieważ koszt wydajności z synchronizacją jest większy. Jednym z takich przypadków jest użycie SimpleDateFormat. Ponieważ SimpleDateFormat nie jest bezpieczny dla wątków, musimy zapewnić mechanizm, aby był bezpieczny dla wątków.

public class ThreadLocalDemo1 implements Runnable {
    // threadlocal variable is created
    private static final ThreadLocal<SimpleDateFormat> dateFormat = new ThreadLocal<SimpleDateFormat>(){
        @Override
        protected SimpleDateFormat initialValue(){
            System.out.println("Initializing SimpleDateFormat for - " + Thread.currentThread().getName() );
            return new SimpleDateFormat("dd/MM/yyyy");
        }
    };

    public static void main(String[] args) {
        ThreadLocalDemo1 td = new ThreadLocalDemo1();
        // Two threads are created
        Thread t1 = new Thread(td, "Thread-1");
        Thread t2 = new Thread(td, "Thread-2");
        t1.start();
        t2.start();
    }

    @Override
    public void run() {
        System.out.println("Thread run execution started for " + Thread.currentThread().getName());
        System.out.println("Date formatter pattern is  " + dateFormat.get().toPattern());
        System.out.println("Formatted date is " + dateFormat.get().format(new Date()));
    } 

}

Od wydania Java 8 istnieje bardziej deklaratywny sposób inicjowania ThreadLocal:

ThreadLocal<Cipher> local = ThreadLocal.withInitial(() -> "init value");

Do czasu wydania Java 8 trzeba było wykonać następujące czynności:

ThreadLocal<String> local = new ThreadLocal<String>(){
    @Override
    protected String initialValue() {
        return "init value";
    }
};

Ponadto, jeśli metoda instancji (konstruktor, metoda fabryczna) klasy, dla której jest używana ThreadLocal, nie przyjmuje żadnych parametrów, możesz po prostu użyć odwołań do metod (wprowadzonych w Javie 8):

class NotThreadSafe {
    // no parameters
    public NotThreadSafe(){}
}

ThreadLocal<NotThreadSafe> container = ThreadLocal.withInitial(NotThreadSafe::new);

Uwaga: Ocena jest leniwa, ponieważ przekazujesz java.util.function.Supplierlambda, która jest oceniana tylko wtedy, gdy ThreadLocal#getjest wywoływana, ale wartość nie była wcześniej oceniana.

Musisz być bardzo ostrożny ze wzorem ThreadLocal. Istnieje kilka poważnych wad, takich jak wspomniany Phil, ale jednym z nich nie było to, aby upewnić się, że kod, który konfiguruje kontekst ThreadLocal, nie jest „ponownie dostępny”.

Złe rzeczy mogą się zdarzyć, gdy kod ustawiający informacje zostanie uruchomiony drugi lub trzeci raz, ponieważ informacje w twoim wątku mogą zacząć mutować, gdy się tego nie spodziewałeś. Dlatego upewnij się, że informacje ThreadLocal nie zostały ustawione przed ponownym ustawieniem.

kiedy?

Jeśli obiekt nie jest bezpieczny dla wątków, zamiast synchronizacji, która utrudnia skalowalność, należy dać jeden obiekt każdemu wątkowi i zachować zakres wątku, którym jest ThreadLocal. Jednym z najczęściej używanych, ale niechronionych wątków obiektów, jest połączenie z bazą danych i JMSConnection.

W jaki sposób ?

Jednym z przykładów jest platforma Spring, która mocno wykorzystuje ThreadLocal do zarządzania transakcjami za kulisami, utrzymując te obiekty połączeń w zmiennych ThreadLocal. Na wysokim poziomie, po rozpoczęciu transakcji, otrzymuje połączenie (i wyłącza automatyczne zatwierdzanie) i utrzymuje je w ThreadLocal. przy kolejnych wywołaniach db używa tego samego połączenia do komunikacji z db. Na koniec pobiera połączenie z ThreadLocal i zatwierdza (lub przywraca) transakcję i zwalnia połączenie.

Myślę, że log4j używa także ThreadLocal do obsługi MDC.

ThreadLocal jest przydatny, gdy chcesz mieć stan, który nie powinien być współużytkowany przez różne wątki, ale powinien być dostępny z każdego wątku przez cały okres jego użytkowania.

Jako przykład wyobraź sobie aplikację internetową, w której każde żądanie jest obsługiwane przez inny wątek. Wyobraź sobie, że do każdego żądania potrzebujesz fragmentu danych wiele razy, co jest dość drogie do obliczenia. Jednak te dane mogły ulec zmianie dla każdego przychodzącego żądania, co oznacza, że ​​nie można użyć zwykłej pamięci podręcznej. Prostym i szybkim rozwiązaniem tego problemu byłoby posiadanie ThreadLocalzmiennej przechowującej dostęp do tych danych, dzięki czemu trzeba ją obliczyć tylko raz dla każdego żądania. Oczywiście ten problem można również rozwiązać bez użycia ThreadLocal, ale opracowałem go w celach ilustracyjnych.

To powiedziawszy, pamiętajcie, że ThreadLocalsą one zasadniczo formą państwa globalnego. W rezultacie ma wiele innych implikacji i należy go stosować dopiero po rozważeniu wszystkich innych możliwych rozwiązań.

Nie ma tu nic nowego, ale dzisiaj odkryłem, że ThreadLocaljest to bardzo przydatne, gdy korzystam z Bean Validation w aplikacji internetowej. Komunikaty sprawdzania poprawności są zlokalizowane, ale domyślnie są używane Locale.getDefault(). Możesz skonfigurować Validatorinny MessageInterpolator, ale nie ma sposobu, aby określić, Localekiedy zadzwoniszvalidate . Możesz więc stworzyć statyczny ThreadLocal<Locale>(lub jeszcze lepiej, ogólny kontener z innymi rzeczami, które mogą być potrzebne, ThreadLocala następnie MessageInterpolatorwybrać niestandardowy Localez tego. Kolejnym krokiem jest napisanie, ServletFilterktóry używa wartości sesji lub request.getLocale()wybór ustawień regionalnych i przechowywania to w twojej ThreadLocalreferencji.

Jak wspomniano w @unknown (google), jego użycie polega na zdefiniowaniu zmiennej globalnej, w której wartość odniesienia może być unikalna w każdym wątku. Jego użycie zwykle oznacza przechowywanie pewnego rodzaju informacji kontekstowych, które są powiązane z bieżącym wątkiem wykonania.

Używamy go w środowisku Java EE, aby przekazać tożsamość użytkownika do klas, które nie są świadome Java EE (nie mają dostępu do HttpSession lub EJB SessionContext). W ten sposób kod, który wykorzystuje tożsamość do operacji opartych na bezpieczeństwie, może uzyskać dostęp do tożsamości z dowolnego miejsca, bez konieczności jawnego przekazywania jej przy każdym wywołaniu metody.

Cykl operacji żądanie / odpowiedź w większości wywołań Java EE ułatwia ten rodzaj użytkowania, ponieważ zapewnia dobrze zdefiniowane punkty wejścia i wyjścia do ustawiania i wyłączania ThreadLocal.

ThreadLocal zapewni dostęp do obiektu zmiennego przez wiele wątków w niezsynchronizowanej metodzie jest zsynchronizowany, co oznacza, że ​​obiekt zmienny będzie niezmienny w obrębie metody.

Osiąga się to poprzez podanie nowej instancji obiektu zmiennego dla każdej próby uzyskania dostępu do wątku. Jest to lokalna kopia dla każdego wątku. Jest to pewien hack przy tworzeniu zmiennej instancji w metodzie dostępnej jak zmienna lokalna. Ponieważ wiesz, że zmienna lokalna metody jest dostępna tylko dla wątku, jedną różnicą jest; zmienne lokalne metody nie będą dostępne dla wątku po zakończeniu wykonywania metody, w której obiekt zmienny współdzielony z Threadlocal będzie dostępny dla wielu metod, dopóki go nie wyczyścimy.

Zgodnie z definicją:

Klasa ThreadLocal w Javie umożliwia tworzenie zmiennych, które mogą być odczytywane i zapisywane tylko przez ten sam wątek. Dlatego nawet jeśli dwa wątki wykonują ten sam kod, a kod zawiera odwołanie do zmiennej ThreadLocal, wówczas oba wątki nie widzą nawzajem swoich zmiennych ThreadLocal.

Każda Threadw java zawiera ThreadLocalMapw sobie.
Gdzie

Key = One ThreadLocal object shared across threads.
value = Mutable object which has to be used synchronously, this will be instantiated for each thread.

Osiągnięcie ThreadLocal:

Teraz stwórz klasę opakowania dla ThreadLocal, która będzie przechowywać zmienny obiekt jak poniżej (z lub bez initialValue()).
Teraz getter i setter tego opakowania będą działały na instancji Threadlocal zamiast obiektu mutable.

Jeśli getter () z Threadlocal nie znalazł żadnej wartości z w Threadlocalmap na Thread; następnie wywoła funkcję initialValue (), aby uzyskać swoją prywatną kopię dotyczącą wątku.

class SimpleDateFormatInstancePerThread {

    private static final ThreadLocal<SimpleDateFormat> dateFormatHolder = new ThreadLocal<SimpleDateFormat>() {

        @Override
        protected SimpleDateFormat initialValue() {
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd") {
                UUID id = UUID.randomUUID();
                @Override
                public String toString() {
                    return id.toString();
                };
            };
            System.out.println("Creating SimpleDateFormat instance " + dateFormat +" for Thread : " + Thread.currentThread().getName());
            return dateFormat;
        }
    };

    /*
     * Every time there is a call for DateFormat, ThreadLocal will return calling
     * Thread's copy of SimpleDateFormat
     */
    public static DateFormat getDateFormatter() {
        return dateFormatHolder.get();
    }

    public static void cleanup() {
        dateFormatHolder.remove();
    }
}

Teraz wrapper.getDateFormatter()zadzwoni threadlocal.get()i sprawdzi, czy currentThread.threadLocalMapzawiera to wystąpienie (Threadlocal).
Jeśli tak, zwróć wartość (SimpleDateFormat) dla odpowiedniej
instancji Threadlocal, w przeciwnym razie dodaj mapę z tą instancją ThreadLocal, initialValue ().

W ten sposób osiągnięto bezpieczeństwo wątków w tej klasie zmiennych; przez każdy wątek działa z własną instancją mutable, ale z tą samą instancją ThreadLocal. Oznacza, że ​​cały wątek będzie współdzielił tę samą instancję ThreadLocal jako klucz, ale inną instancję SimpleDateFormat jako wartość.

https://github.com/skanagavelu/yt.tech/blob/master/src/ThreadLocalTest.java

Zmienne lokalne wątków są często używane, aby zapobiec współużytkowaniu w projektach opartych na zmiennych Singletonach lub zmiennych globalnych.

Może być używany w scenariuszach takich jak nawiązywanie oddzielnego połączenia JDBC dla każdego wątku, gdy nie używasz puli połączeń.

private static ThreadLocal<Connection> connectionHolder
           = new ThreadLocal<Connection>() {
      public Connection initialValue() {
           return DriverManager.getConnection(DB_URL);
          }
     };

public static Connection getConnection() {
      return connectionHolder.get();
} 

Wywołanie getConnection spowoduje zwrócenie połączenia powiązanego z tym wątkiem. To samo można zrobić z innymi właściwościami, takimi jak dateformat, kontekst transakcji, którego nie chcesz udostępniać między wątkami.

Mogłeś również użyć zmiennych lokalnych do tego samego, ale te zasoby zwykle zajmują dużo czasu podczas tworzenia, więc nie chcesz ich tworzyć ponownie za każdym razem, gdy wykonujesz z nimi logikę biznesową. Jednak wartości ThreadLocal są przechowywane w samym obiekcie wątku i gdy tylko wątek zostanie wyrzucony, elementy te również znikają.

Ten link bardzo dobrze wyjaśnia użycie ThreadLocal.

ThreadLocal klasa w Java umożliwia tworzenie zmiennych, które mogą być odczytywane i zapisywane przez tego samego wątku tylko. Dlatego nawet jeśli dwa wątki wykonują ten sam kod, a kod zawiera odwołanie do zmiennej ThreadLocal, wówczas oba wątki nie widzą nawzajem swoich zmiennych ThreadLocal.

Czytaj więcej

Istnieją 3 scenariusze korzystania z pomocnika klasy, takiego jak SimpleDateFormat w kodzie wielowątkowym, z których najlepszym jest użycie ThreadLocal

Scenariusze

1- Korzystanie z podobnego obiektu udostępniania za pomocą mechanizmu blokady lub synchronizacji , który spowalnia działanie aplikacji

2- Używanie jako obiektu lokalnego w metodzie

W tym scenariuszu, jeśli mamy 4 wątki, każdy wywołuje metodę 1000 razy, to mamy
4000 obiektów SimpleDateFormat utworzonych i oczekujących na ich usunięcie przez GC

3- Korzystanie z ThreadLocal

jeśli mamy 4 wątki i podaliśmy każdemu wątkowi jedną instancję SimpleDateFormat,
więc mamy 4 wątki , 4 obiekty SimpleDateFormat.

Nie ma potrzeby blokowania mechanizmu oraz tworzenia i niszczenia obiektów. (Dobra złożoność czasu i złożoność przestrzeni)

[Dla odniesienia] ThreadLocal nie może rozwiązać problemów z aktualizacją współdzielonego obiektu. Zalecane jest użycie obiektu staticThreadLocal, który jest wspólny dla wszystkich operacji w tym samym wątku. [Obowiązkowe] metoda remove () musi być zaimplementowana przez zmienne ThreadLocal, szczególnie przy użyciu pul wątków, w których wątki są często ponownie wykorzystywane. W przeciwnym razie może to wpłynąć na późniejszą logikę biznesową i spowodować nieoczekiwane problemy, takie jak wyciek pamięci.

Buforowanie, czasami musisz obliczyć tę samą wartość dużo czasu, więc przechowując ostatni zestaw danych wejściowych w metodzie, a wynik możesz przyspieszyć kod. Używając Thread Local Storage, nie musisz myśleć o blokowaniu.

ThreadLocal jest specjalnie wyposażoną funkcją JVM, która zapewnia izolowane miejsce do przechowywania tylko dla wątków. podobnie jak wartość zmiennej o zasięgu instancji są powiązane tylko z danym wystąpieniem klasy. każdy obiekt ma swoje jedyne wartości i nie mogą widzieć siebie nawzajem. podobnie jest koncepcja zmiennych ThreadLocal, są one lokalne dla wątku w sensie instancji obiektu inny wątek, z wyjątkiem tego, który go utworzył, nie może go zobaczyć. Spójrz tutaj

import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.IntStream;


public class ThreadId {
private static final AtomicInteger nextId = new AtomicInteger(1000);

// Thread local variable containing each thread's ID
private static final ThreadLocal<Integer> threadId = ThreadLocal.withInitial(() -> nextId.getAndIncrement());


// Returns the current thread's unique ID, assigning it if necessary
public static int get() {
    return threadId.get();
}

public static void main(String[] args) {

    new Thread(() -> IntStream.range(1, 3).forEach(i -> {
        System.out.println(Thread.currentThread().getName() + " >> " + new ThreadId().get());
    })).start();

    new Thread(() -> IntStream.range(1, 3).forEach(i -> {
        System.out.println(Thread.currentThread().getName() + " >> " + new ThreadId().get());
    })).start();

    new Thread(() -> IntStream.range(1, 3).forEach(i -> {
        System.out.println(Thread.currentThread().getName() + " >> " + new ThreadId().get());
    })).start();

}
}

Threadlocal zapewnia bardzo łatwy sposób na ponowne użycie obiektów przy zerowym koszcie.

Miałem sytuację, w której wiele wątków tworzyło obraz modyfikowalnej pamięci podręcznej przy każdym powiadomieniu o aktualizacji.

Użyłem Threadlocal dla każdego wątku, a następnie każdy wątek musiałby po prostu zresetować stary obraz, a następnie zaktualizować go ponownie z pamięci podręcznej przy każdym powiadomieniu o aktualizacji.

Zwykłe obiekty wielokrotnego użytku z pul obiektów są powiązane z kosztami bezpieczeństwa wątków, podczas gdy takie podejście nie ma żadnego.

Wypróbuj ten mały przykład, aby poznać zmienną ThreadLocal:

public class Book implements Runnable {
    private static final ThreadLocal<List<String>> WORDS = ThreadLocal.withInitial(ArrayList::new);

    private final String bookName; // It is also the thread's name
    private final List<String> words;


    public Book(String bookName, List<String> words) {
        this.bookName = bookName;
        this.words = Collections.unmodifiableList(words);
    }

    public void run() {
        WORDS.get().addAll(words);
        System.out.printf("Result %s: '%s'.%n", bookName, String.join(", ", WORDS.get()));
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new Book("BookA", Arrays.asList("wordA1", "wordA2", "wordA3")));
        Thread t2 = new Thread(new Book("BookB", Arrays.asList("wordB1", "wordB2")));
        t1.start();
        t2.start();
    }
}

Dane wyjściowe konsoli, jeśli wątek BookA zostanie wykonany jako pierwszy:
Wynik BookA: „słowo A1, słowo A2, słowo A3”.
Wynik BookB: „słowo B1, słowo B2”.

Dane wyjściowe konsoli, jeśli wątek BookB zostanie zrobiony jako pierwszy:
Wynik BookB: 'wordB1, wordB2'.
Księga wyników A: „słowo A1, słowo A2, słowo A3”.