Jaka jest różnica między ConcurrentHashMap a kolekcjami.synchronizedMap (Mapa)?

╔═══════════════╦═══════════════════╦═══════════════════╦═════════════════════╗
║   Property    ║     HashMap       ║    Hashtable      ║  ConcurrentHashMap  ║
╠═══════════════╬═══════════════════╬═══════════════════╩═════════════════════╣ 
║      Null     ║     allowed       ║              not allowed                ║
║  values/keys  ║                   ║                                         ║
╠═══════════════╬═══════════════════╬═════════════════════════════════════════╣
║ Thread-safety ║                   ║                                         ║
║   features    ║       no          ║                  yes                    ║
╠═══════════════╬═══════════════════╬═══════════════════╦═════════════════════╣
║     Lock      ║       not         ║ locks the whole   ║ locks the portion   ║        
║  mechanism    ║    applicable     ║       map         ║                     ║ 
╠═══════════════╬═══════════════════╩═══════════════════╬═════════════════════╣
║   Iterator    ║               fail-fast               ║ weakly consistent   ║ 
╚═══════════════╩═══════════════════════════════════════╩═════════════════════╝

Odnośnie mechanizmu blokującego: Hashtable blokuje obiekt , podczas gdy ConcurrentHashMap blokuje tylko wiadro .

"problemy ze skalowalnością" dla {[0] } występują dokładnie tak samo w Collections.synchronizedMap(Map) - używają bardzo prostej synchronizacji, co oznacza, że tylko jeden wątek może uzyskać dostęp do mapy w tym samym czasie.

Nie jest to zbyt duży problem, gdy masz proste wstawki i wyszukiwanie (chyba że robisz to bardzo intensywnie), ale staje się dużym problemem, gdy trzeba iterację na całej mapie, co może zająć dużo czasu dla dużej mapy - podczas gdy jeden wątek robi to, wszystkie inne muszą czekać, jeśli nie będą się one wyświetlać. chcesz wstawić lub wyszukać cokolwiek.

ConcurrentHashMap używa bardzo wyrafinowanych technik, aby zmniejszyć potrzebę synchronizacji i umożliwić równoległy dostęp do odczytu przez wiele wątków bez synchronizacji i, co ważniejsze, zapewnia Iterator, który nie wymaga synchronizacji, a nawet pozwala na modyfikację mapy podczas interakcji (choć nie gwarantuje, czy elementy wstawione podczas iteracji zostaną zwrócone).

ConcurrentHashMap jest preferowany, gdy można go używać - chociaż wymaga co najmniej Java 5.

Jest zaprojektowany tak, aby dobrze skalować, gdy jest używany przez wiele wątków. Wydajność może być nieznacznie gorsza, gdy tylko jeden wątek uzyskuje dostęp do mapy na raz, ale znacznie lepsza, gdy wiele wątków uzyskuje dostęp do mapy jednocześnie.

Znalazłem wpis na blogu , który odtwarza tabelę ze znakomitej książki współbieżność Javy w praktyce , którą dokładnie polecam.

Kolekcje.synchronizedMap ma sens tylko wtedy, gdy trzeba zawinąć mapę z innymi cechami, być może jakąś uporządkowaną mapą, jak mapa drzewa.

Główna różnica między tymi dwoma jest taka, że ConcurrentHashMap zablokuje tylko część danych, które są aktualizowane, podczas gdy inne części danych mogą być dostępne przez inne wątki. Jednakże Collections.synchronizedMap() zablokuje wszystkie dane podczas aktualizacji, inne wątki będą miały dostęp do danych dopiero po zwolnieniu blokady. Jeśli istnieje wiele operacji aktualizacji i stosunkowo niewielka ilość operacji odczytu, należy wybrać ConcurrentHashMap.

Jeszcze jedna różnica polega na tym, że ConcurrentHashMap nie zachowa kolejności elementy na mapie przeszły. Jest podobny do HashMap podczas przechowywania danych. Nie ma gwarancji, że kolejność elementów zostanie zachowana. Podczas gdy Collections.synchronizedMap() zachowa kolejność elementów przekazywanej Mapy. Na przykład, jeśli przekazujesz TreeMap do ConcurrentHashMap, kolejność elementów w ConcurrentHashMap może nie być taka sama jak kolejność w TreeMap, ale Collections.synchronizedMap() zachowa kolejność.

Ponadto, {[0] } może zagwarantować, że nie ma ConcurrentModificationException rzuconego podczas gdy jeden wątek aktualizuje mapę, a drugi wątek jest przemierzanie iteratora uzyskanego z mapy. Jednak Collections.synchronizedMap() nie jest w tym zagwarantowana.

Jest jeden post, który pokazuje różnice tych dwóch, a także ConcurrentSkipListMap.

Mapa Synchroniczna:

Synchronized Map nie różni się zbytnio od Hashtable i zapewnia podobną wydajność w współbieżnych programach Java. Jedyną różnicą między Hashtable i SynchronizedMap jest to, że SynchronizedMap nie jest dziedzictwem i możesz owinąć dowolną mapę, aby utworzyć jej zsynchronizowaną wersję za pomocą Kolekcji.metoda synchronizedMap ().

ConcurrentHashMap:

Klasa ConcurrentHashMap zapewnia współbieżną wersję standardu HashMap. Jest to ulepszenie funkcjonalności synchronizedMap dostarczanej w klasie Collections.

W Przeciwieństwie Do Hashtable i zsynchronizowanej mapy, Nigdy nie blokuje całej mapy, zamiast tego dzieli mapę na segmenty i blokuje na nich. Działa lepiej, jeśli liczba wątków czytnika jest większa niż liczba wątków Writera.

ConcurrentHashMap domyślnie jest rozdzielony na 16 regionów i stosowane są blokady. Ten domyślny numer może być ustawiony podczas inicjalizacji Instancja ConcurrentHashMap. Podczas ustawiania danych w danym segmencie uzyskuje się blokadę dla tego segmentu. Oznacza to, że dwie aktualizacje mogą być wykonywane jednocześnie bezpiecznie, jeśli każda z nich wpływa na oddzielne łyżki, minimalizując w ten sposób niezgodność blokady i maksymalizując w ten sposób wydajność.

ConcurrentHashMap nie rzuca ConcurrentModificationException

ConcurrentHashMap nie wyrzuca ConcurrentModificationException, jeśli jeden wątek próbuje go zmodyfikować, podczas gdy inny jest iteracyjny it

Różnica między synchornizedMap i ConcurrentHashMap

Kolekcje.synchornizedMap (HashMap) zwróci kolekcję, która jest prawie równoważna Hashtable, gdzie każda operacja modyfikacji na mapie jest zablokowana na obiekcie mapy, podczas gdy w przypadku ConcurrentHashMap, bezpieczeństwo wątku jest osiągane przez podzielenie całej mapy na inną partycję w oparciu o poziom współbieżności i tylko blokowanie określonej części zamiast blokowania całej mapy.

ConcurrentHashMap nie zezwala na klucze null ani wartości null, podczas gdy zsynchronizowana HashMap zezwala na jeden klucz null.

Podobne linki

Link1

Link2

Porównanie Wydajności

• Hashtable oraz ConcurrentHashMap nie zezwalaj na klucze null ani wartości null.

• Collections.synchronizedMap(Map) synchronizuje wszystkie operacje (get, put, size, itp.).

• ConcurrentHashMap obsługuje pełną współbieżność pobierania i regulowaną oczekiwaną współbieżność aktualizacji.

Jak zwykle, w grę wchodzą współbieżne ... overhead ... speed tradeoffs. Naprawdę trzeba wziąć pod uwagę szczegółową współbieżność wymagania aplikacji, aby podjąć decyzję, a następnie przetestować kod, aby sprawdzić, czy jest wystarczająco dobry.

W ConcurrentHashMap blokada jest stosowana do segmentu zamiast całej mapy. Każdy segment zarządza własną wewnętrzną tabelą hash. Blokada jest stosowana tylko do operacji aktualizacji. Collections.synchronizedMap(Map) synchronizuje całą mapę.

Masz rację co do HashTable, Możesz o tym zapomnieć.

Twój artykuł wspomina o tym, że chociaż HashTable i klasa wrapper synchronized zapewniają podstawowe bezpieczeństwo wątku, pozwalając tylko jednemu wątkowi na dostęp do mapy, nie jest to "prawdziwe" bezpieczeństwo wątku, ponieważ wiele operacji złożonych nadal wymaga dodatkowej synchronizacji, na przykład:]}

synchronized (records) {
  Record rec = records.get(id);
  if (rec == null) {
      rec = new Record(id);
      records.put(id, rec);
  }
  return rec;
}

Jednak nie myśl, że ConcurrentHashMap jest prostą alternatywą dla HashMap z typowym synchronized blokiem, jak pokazano powyżej. Przeczytaj ten artykuł , aby lepiej zrozumieć jego zawiłości.

Oto kilka :

1) ConcurrentHashMap blokuje tylko część mapy, ale SynchronizedMap blokuje całą mapę.
2) ConcurrentHashMap ma lepszą wydajność nad SynchronizedMap i jest bardziej skalowalny.
3) w przypadku wielu czytników i jednego Writera ConcurrentHashMap jest najlepszym wyborem.

Ten tekst pochodzi z różnicy między ConcurrentHashMap i hashtable w Javie

Możemy osiągnąć bezpieczeństwo wątku używając ConcurrentHashMap oraz synchronisedHashmap i Hashtable. Ale jest duża różnica, jeśli spojrzeć na ich architekturę.

1. synchronisedHashmap and Hashtable

Oba utrzymają blokadę na poziomie obiektu. Więc jeśli chcesz wykonać jakąkolwiek operację, taką jak put / get, musisz najpierw zdobyć blokadę. Jednocześnie inne wątki nie mogą wykonywać żadnej operacji. / Align = "left" / thread może na tym działać. Więc czas oczekiwania wzrośnie tutaj. Możemy powiedzieć, że wydajność jest stosunkowo niska w porównaniu z ConcurrentHashMap.

1. ConcurrentHashMap

Utrzyma blokadę na poziomie segmentu. Posiada 16 segmentów i domyślnie utrzymuje poziom współbieżności jako 16. Tak więc w czasie, 16 wątków może być w stanie działać na ConcurrentHashMap. Ponadto operacja odczytu nie wymaga blokady. Więc dowolna liczba wątków może wykonaj na nim operację get.

Jeśli thread1 chce wykonać operację put w segmencie 2, a thread2 chce wykonać operację put w segmencie 4, to jest dozwolone tutaj. Oznacza to, że 16 wątków może wykonywać operację aktualizacji (put/delete) na ConcurrentHashMap na raz.

Aby czas oczekiwania był tutaj krótszy. Stąd wydajność jest stosunkowo lepsza niż synchronisedHashmap i Hashtable.

ConcurrentHashMap

• powinieneś używać ConcurrentHashMap, gdy potrzebujesz bardzo wysokiej współbieżności w swoim projekcie.
• jest bezpieczny dla wątków bez synchronizacji całej mapy.
• odczyt może nastąpić bardzo szybko, podczas gdy zapis jest wykonywany za pomocą blokady.
• nie ma blokady na poziomie obiektu.
[[5]}blokada jest o wiele bardziej ziarnista na poziomie łyżki hashmap.
• ConcurrentHashMap nie rzuca ConcurrentModificationException jeśli jeden wątek próbuje go zmodyfikować, podczas gdy inny jest iteracją nad nim.
• ConcurrentHashMap używa wielu blokad.

SynchronizedHashMap

• Synchronizacja na poziomie obiektu.
• Każda operacja odczytu/zapisu wymaga uzyskania blokady.
• blokowanie całego zbioru jest działaniem nadrzędnym.
• to zasadniczo daje dostęp tylko do jednego wątku na całej mapie i blokuje wszystkie pozostałe wątki.
• Może powodować spór.
• SynchronizedHashMap zwraca Iterator, który nie działa-szybko przy jednoczesnej modyfikacji.

Źródło

ConcurrentHashMap jest zoptymalizowany pod kątem współbieżnego dostępu.

Dostępy nie blokują całej mapy, ale wykorzystują bardziej precyzyjną strategię, która poprawia skalowalność. Istnieją również rozszerzenia funkcjonalne specjalnie dla dostępu współbieżnego, np. Iteratory współbieżne.

Istnieje jedna krytyczna cecha do zwrócenia uwagi na ConcurrentHashMap inna niż funkcja współbieżności, którą dostarcza, czyli iterator fail-safe. Widziałem deweloperów używających ConcurrentHashMap tylko dlatego, że chcą edytować entryset-put/remove podczas iteracji nad nim. Collections.synchronizedMap(Map) nie dostarcza iteratorafail-safe , ale zamiast niego dostarcza iteratoraFail-fast . Iteratory fail-fast wykorzystują migawkę wielkości mapy, której nie można edytować podczas iteracji.

1. Jeśli spójność danych jest bardzo ważna-użyj Hashtable lub Collections.synchronizedMap(Mapa).
2. Jeśli szybkość / wydajność jest bardzo ważna i aktualizacja danych może być zagrożona-użyj ConcurrentHashMap.

Ogólnie rzecz biorąc, jeśli chcesz użyć ConcurrentHashMap upewnij się, że jesteś gotowy do pominięcia 'updates'
(tzn. wydrukowanie zawartości Hashmapy nie gwarantuje, że wydrukuje aktualną mapę) i użyj API podobnych do CyclicBarrier, aby zapewnić spójność w całym cyklu życia programu.

Kolekcje.metoda synchronizedMap() synchronizuje wszystkie metody HashMap i skutecznie redukuje je do struktury danych, do której jeden wątek może wejść na raz, ponieważ blokuje wszystkie metody na wspólnej blokadzie.

W ConcurrentHashMap synchronizacja odbywa się nieco inaczej. Zamiast blokowania każdej metody na wspólnej blokadzie, ConcurrentHashMap używa oddzielnej blokady dla oddzielnych łyżek, blokując tym samym tylko część mapy. Domyślnie jest 16 wiader, a także oddzielne Zamki na oddzielne wiadra. Domyślnym poziomem współbieżności jest 16. Oznacza to, że teoretycznie w danym momencie 16 wątków może uzyskać dostęp do ConcurrentHashMap, jeśli wszystkie będą oddzielać wiadra.

ConcurrentHashMap został przedstawiony jako alternatywa dla Hashtable w Javie 1.5 jako część pakietu współbieżności. Dzięki ConcurrentHashMap masz lepszy wybór nie tylko wtedy, gdy może być bezpiecznie używany w równoległym środowisku wielowątkowym, ale także zapewnia lepszą wydajność niż Hashtable i synchronizedMap. ConcurrentHashMap działa lepiej, ponieważ blokuje część mapy. Pozwala na zgodne operacje odczytu i jednocześnie zachowuje integralność poprzez synchronizację zapisu szef.

Jak zaimplementowana jest ConcurrentHashMap

ConcurrentHashMap został opracowany jako alternatywa dla Hashtable i obsługuje wszystkie funkcjonalności Hashtable z dodatkową możliwością, tzw. concurrency level. ConcurrentHashMap umożliwia jednoczesne odczytywanie wielu czytników bez użycia bloków. Staje się to możliwe, rozdzielając mapę na różne części i blokując tylko część mapy w aktualizacjach. Domyślnie poziom współbieżności wynosi 16, więc mapa jest podzielona na 16 części, a każda część jest zarządzane przez oddzielony blok. Oznacza to, że 16 wątków może pracować z mapą jednocześnie, jeśli działają z różnymi częściami Mapy. Sprawia, że ConcurrentHashMap jest wydajny, a nie obniża bezpieczeństwo wątków.

Jeśli interesuje Cię kilka ważnych funkcji ConcurrentHashMap i kiedy powinieneś skorzystać z tej realizacji Map-właśnie zamieszczam link do dobrego artykułu - Jak korzystać z ConcurrentHashMap w Javie

Poza tym, co zostało zasugerowane, chciałbym opublikować kod źródłowy związany z SynchronizedMap.

Aby zabezpieczyć wątek Map, możemy użyć instrukcji Collections.synchronizedMap i wprowadzić instancję map jako parametr.

Implementacja synchronizedMap w Collections jest jak poniżej

   public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
        return new SynchronizedMap<>(m);
    }

Jak widać, obiekt wejściowy Map jest zawinięty przez obiekt SynchronizedMap.
Przyjrzyjmy się implementacji SynchronizedMap,

 private static class SynchronizedMap<K,V>
        implements Map<K,V>, Serializable {
        private static final long serialVersionUID = 1978198479659022715L;

        private final Map<K,V> m;     // Backing Map
        final Object      mutex;        // Object on which to synchronize

        SynchronizedMap(Map<K,V> m) {
            this.m = Objects.requireNonNull(m);
            mutex = this;
        }

        SynchronizedMap(Map<K,V> m, Object mutex) {
            this.m = m;
            this.mutex = mutex;
        }

        public int size() {
            synchronized (mutex) {return m.size();}
        }
        public boolean isEmpty() {
            synchronized (mutex) {return m.isEmpty();}
        }
        public boolean containsKey(Object key) {
            synchronized (mutex) {return m.containsKey(key);}
        }
        public boolean containsValue(Object value) {
            synchronized (mutex) {return m.containsValue(value);}
        }
        public V get(Object key) {
            synchronized (mutex) {return m.get(key);}
        }

        public V put(K key, V value) {
            synchronized (mutex) {return m.put(key, value);}
        }
        public V remove(Object key) {
            synchronized (mutex) {return m.remove(key);}
        }
        public void putAll(Map<? extends K, ? extends V> map) {
            synchronized (mutex) {m.putAll(map);}
        }
        public void clear() {
            synchronized (mutex) {m.clear();}
        }

        private transient Set<K> keySet;
        private transient Set<Map.Entry<K,V>> entrySet;
        private transient Collection<V> values;

        public Set<K> keySet() {
            synchronized (mutex) {
                if (keySet==null)
                    keySet = new SynchronizedSet<>(m.keySet(), mutex);
                return keySet;
            }
        }

        public Set<Map.Entry<K,V>> entrySet() {
            synchronized (mutex) {
                if (entrySet==null)
                    entrySet = new SynchronizedSet<>(m.entrySet(), mutex);
                return entrySet;
            }
        }

        public Collection<V> values() {
            synchronized (mutex) {
                if (values==null)
                    values = new SynchronizedCollection<>(m.values(), mutex);
                return values;
            }
        }

        public boolean equals(Object o) {
            if (this == o)
                return true;
            synchronized (mutex) {return m.equals(o);}
        }
        public int hashCode() {
            synchronized (mutex) {return m.hashCode();}
        }
        public String toString() {
            synchronized (mutex) {return m.toString();}
        }

        // Override default methods in Map
        @Override
        public V getOrDefault(Object k, V defaultValue) {
            synchronized (mutex) {return m.getOrDefault(k, defaultValue);}
        }
        @Override
        public void forEach(BiConsumer<? super K, ? super V> action) {
            synchronized (mutex) {m.forEach(action);}
        }
        @Override
        public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
            synchronized (mutex) {m.replaceAll(function);}
        }
        @Override
        public V putIfAbsent(K key, V value) {
            synchronized (mutex) {return m.putIfAbsent(key, value);}
        }
        @Override
        public boolean remove(Object key, Object value) {
            synchronized (mutex) {return m.remove(key, value);}
        }
        @Override
        public boolean replace(K key, V oldValue, V newValue) {
            synchronized (mutex) {return m.replace(key, oldValue, newValue);}
        }
        @Override
        public V replace(K key, V value) {
            synchronized (mutex) {return m.replace(key, value);}
        }
        @Override
        public V computeIfAbsent(K key,
                Function<? super K, ? extends V> mappingFunction) {
            synchronized (mutex) {return m.computeIfAbsent(key, mappingFunction);}
        }
        @Override
        public V computeIfPresent(K key,
                BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
            synchronized (mutex) {return m.computeIfPresent(key, remappingFunction);}
        }
        @Override
        public V compute(K key,
                BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
            synchronized (mutex) {return m.compute(key, remappingFunction);}
        }
        @Override
        public V merge(K key, V value,
                BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
            synchronized (mutex) {return m.merge(key, value, remappingFunction);}
        }

        private void writeObject(ObjectOutputStream s) throws IOException {
            synchronized (mutex) {s.defaultWriteObject();}
        }
    }

Co robi SynchronizedMap można podsumować jako dodanie pojedynczej blokady do metoda podstawowa obiektu input Map. Wszystkie metody strzeżone przez blokadę nie mogą być dostępne przez wiele wątków jednocześnie. Oznacza to, że normalne operacje, takie jak put i get mogą być wykonywane przez jeden wątek w tym samym czasie dla wszystkich danych w obiekcie Map.

Sprawia, że wątek obiektu Map jest teraz bezpieczny, ale wydajność może stać się problemem w niektórych scenariuszach.

ConcurrentMap jest znacznie bardziej skomplikowana w implementacji, możemy odnieść się do budowania lepszego HashMap dla szczegółów. W skrócie, jest zaimplementowany, biorąc pod uwagę zarówno bezpieczeństwo wątku, jak i wydajność.