Besoin d'une explication simple sur la façon dont "lock striping" fonctionne avec ConcurrentHashMap

Selon la Java de la Simultanéité dans la Pratique, chapitre 11.4.3 dit:

De verrouillage de la division peut parfois être étendue à la partition
verrouillage sur un variablesized ensemble d'objets indépendants, auquel cas
il est appelé le verrou de l'entrelacement. Par exemple, la mise en œuvre de
ConcurrentHashMap utilise un tableau de 16 écluses, dont chacun gardes 1/16
de la table de hachage des seaux; seau N est gardé par écluse N mod 16.

J'ai toujours des problèmes pour comprendre et visualiser le verrouillage de l'entrelacement et de seaux mécanisme.
Quelqu'un peut-il expliquer cela avec une bonne compréhension des mots 🙂

Merci d'avance.

source d'informationauteur GedankenNebel

  1. 32

    Le hachage de la carte est construite sur un tableau, où la fonction de hachage cartes d'un objet à un élément dans le tableau. Disons que le sous-jacent matrice de 1024 éléments - ConcurrentHashMap en fait, transforme ce dans 16 différents sous-ensembles de 64 éléments, par exemple {0, 63}, {64, 127}, etc. Chaque sous-tableau a son propre cadenas, de sorte que la modification de l' {0, 63} de sous-réseau n'a pas d'impact {64, 127} de sous-réseau - un thread peut écrire à la première sous-tableau, tandis qu'un autre thread écrit à la deuxième sous-ensemble.

  2. 12

    La différence entre le verrouillage dans un Collections.synchronizedMap() et un ConcurrentHashMap est comme suit:

    Si plusieurs threads d'accéder à un Collections.synchronizedMap() souvent, il y aura beaucoup de controverse depuis chaque méthode est synchronisé à l'aide d'un verrou partagé (c'est à dire si la thread X appelle une méthode sur un Collections.synchronizedMap()tous les autres threads bloqués à partir de l'appel d'une méthode sur un Collections.synchronizedMap() jusqu'à ce thread X renvoie à partir de la méthode qu'il appelle).

    Un ConcurrentHashMap a un nombre variable de serrures (la valeur par défaut est de 16 ans) que chacun garde un segment de la clés dans la ConcurrentHashMap. Donc, pour un ConcurrentHashMap avec 160 touches, chaque verrou de la garde de 10 éléments. Par conséquent, les méthodes d'exploitation sur une clé (getputsetetc...) uniquement verrouiller l'accès à d'autres méthodes d'exploitation sur une clé où les clés sont dans le même segment. Par exemple, si la thread X appels put(0, someObject)puis visser Y appelle put(10, someOtherObject) ces appels peuvent exécuter en même temps que, de fil et d'Y ne pas avoir à attendre pour le fil X de retour de put(0, someObject). Un exemple est fourni ci-dessous.

    En outre, certaines méthodes telles que size() et isEmpty() ne sont pas protégés. Tout cela permet une plus grande concurrence, cela signifie qu'ils ne sont pas très cohérents (elles ne reflètent pas l'état qui est en même temps changer). 

    public static void main(String[] args) {
  ConcurrentHashMap<Integer, Object> map = new ConcurrentHashMap<>(160);

  new Thread(new Runnable() {
    @Override
    public void run() {
      map.put(0, "guarded by one lock");
    }
  }.start();

  new Thread(new Runnable() {
    @Override
    public void run() {
      map.put(10, "guarded by another lock");
    }
  }.start();

  new Thread(new Runnable() {
    @Override
    public void run() {
      //could print 0, 1, or 2
      System.out.println(map.count());
    }
  }.start();
}
  3. 3

    Le concept clé est le "seau" . au lieu d'utiliser un verrou global pour l'ensemble de la Table de hachage, il utilise un petit cadenas pour chaque seau.
    C'est aussi un bon analogue à seau trier ce qui peut améliorer le tri de la complexité.