Jak działa ConcurrentHashMap w Javie?

By /

Java

ConcurrentHashMap to implementacja mapy w Javie, która umożliwia bezpieczne korzystanie z wielu wątków bez konieczności blokowania całej mapy. Jest to kluczowy element w programowaniu współbieżnym, gdzie dostęp do wspólnych zasobów musi być zarządzany efektywnie, aby uniknąć problemów takich jak wyścigi czy blokady. W tym artykule przyjrzymy się, jak ConcurrentHashMap osiąga swoją wysoką wydajność i przeanalizujemy kompletny przykład kodu.

Rozbudowany przykład użycia ConcurrentHashMap

W poniższym przykładzie zobaczymy, jak używać ConcurrentHashMap do zarządzania stanem, który jest aktualizowany przez wiele wątków. Przykład zawiera klasę Main, w której tworzona jest mapa, a następnie różne wątki dokonują w niej aktualizacji.

import java.util.concurrent.ConcurrentHashMap;

public class Main {
    public static void main(String[] args) {
        // Tworzymy ConcurrentHashMap przechowującą Integer
        ConcurrentHashMap<String, Integer> stock = new ConcurrentHashMap<>();

        // Dodajemy początkowe wartości do mapy
        stock.put("apple", 10);
        stock.put("orange", 20);

        // Tworzymy wątek aktualizujący zapasy jabłek
        Thread updateApples = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                stock.computeIfPresent("apple", (key, val) -> val + 1);
                // Zwiększamy stan jabłek o 1
                try {
                    Thread.sleep(100); // Symulacja pracy
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // Tworzymy wątek aktualizujący zapasy pomarańczy
        Thread updateOranges = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                stock.computeIfPresent("orange", (key, val) -> val + 2);
                // Zwiększamy stan pomarańczy o 2
                try {
                    Thread.sleep(100); // Symulacja pracy
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // Uruchamiamy oba wątki
        updateApples.start();
        updateOranges.start();

        // Oczekujemy zakończenia pracy obu wątków
        try {
            updateApples.join();
            updateOranges.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Wyświetlamy końcowe stany zapasów
        stock.forEach((key, value) -> System

W tym przykładzie, ConcurrentHashMap stock jest współdzielona między dwa wątki, które aktualizują zapasy owoców. Metoda computeIfPresent jest używana do atomowego zwiększania wartości w mapie. Dzięki temu nie musimy się martwić o ryzyko wystąpienia wyścigów czy błędów spójności podczas aktualizacji.

Podsumowanie

ConcurrentHashMap w Javie jest potężnym narzędziem do zarządzania danymi w środowisku wielowątkowym, eliminując potrzebę synchronizacji na całym obiekcie i zamiast tego umożliwiając efektywną i bezpieczną aktualizację poszczególnych elementów. Wykorzystanie metod takich jak computeIfPresent pozwala na bezpieczne operacje aktualizacyjne, które są kluczowe w środowiskach produkcyjnych o wysokiej wydajności.

Jeżeli chcesz przyśpieszyć swoją naukę tworzenia stron chciałbym polecić mój kurs video Java w którym nauczysz się tego języka od podstaw do zaawansowanych jego aspektów.

Powiązane artykuły

Scroll to Top