Utilisation de ConcurrentHashMap, quand la synchronisation est-elle nécessaire?

J'ai un ConcurrentHashMap où je ne les suivants:

sequences = new ConcurrentHashMap<Class<?>, AtomicLong>();

if(!sequences.containsKey(table)) {
    synchronized (sequences) {
        if(!sequences.containsKey(table))
            initializeHashMapKeyValue(table);
    }
}

Ma question est: est - il inutile de faire de l'extra

if(!sequences.containsKey(table))

Vérifier à l'intérieur de la synschronized bloc de sorte que les autres threads habitude initialiser la même table de hachage de la valeur?

Peut-être que la vérification est nécessaire et je fais de mal? Il semble un peu idiot ce que je fais, mais je pense que c'est nécessaire.

source d'informationauteur Per Stilling | 2013-02-13

  1. 20

    Tous opérations sur un ConcurrentHashMap sont thread-safe, mais les opérations thread-safe ne sont pas composables. Vous essayer de faire atomique d'une paire d'activités: vérification pour quelque chose dans la carte et, dans le cas où il n'est pas là, mettre quelque chose là-bas (je suppose). Donc la réponse à vos questions est ouivous avez besoin de vérifier à nouveau, et que ton code a l'air correct.

  2. 16

    Vous devriez être en utilisant la putIfAbsent méthodes de ConcurrentMap.

    ConcurrentMap<String, AtomicLong> map = new ConcurrentHashMap<String, AtomicLong> ();

public long addTo(String key, long value) {
  //The final value it became.
  long result = value;
  //Make a new one to put in the map.
  AtomicLong newValue = new AtomicLong(value);
  //Insert my new one or get me the old one.
  AtomicLong oldValue = map.putIfAbsent(key, newValue);
  //Was it already there? Note the deliberate use of '!='.
  if ( oldValue != newValue ) {
    //Update it.
    result = oldValue.addAndGet(value);
  }
  return result;
}

    Fonctionnelle puristes d'entre nous, le ci-dessus peut être simplifiée (ou peut-être complexified):

    public long addTo(String key, long value) {
    return map.putIfAbsent(key, new AtomicLong()).addAndGet(value);
}

    Et dans Java 8, nous pouvons éviter la création inutile d'un AtomicLong:

    public long addTo8(String key, long value) {
    return map.computeIfAbsent(key, k -> new AtomicLong()).addAndGet(value);
}
  3. 3

    Vous ne pouvez pas obtenir verrou exclusif avec ConcurrentHashMap. Dans de tels cas, il est mieux d'utiliser Synchronisé HashMap.

    Il y a déjà un atomique méthode pour mettre à l'intérieur ConcurrentHashMap si l'objet n'est pas déjà là; putIfAbsent

  4. 1

    Je vois ce que vous avez fait 😉 la question est de ne vous voir vous-même?

    Tout d'abord tout ce que vous avez utilisé quelque chose qui s'appelle "la Double vérification de verrouillage modèle". Où vous avez accès rapide (première contient) qui n'a pas besoin de synchronisation des cas, il est satisfait et lent cheminement qui doit être synchronisé parce que vous n'avez opération complexe. Votre opération consiste à vérifier si quelque chose est à l'intérieur de la carte, puis y mettre quelque chose /initialisation. Donc, il n'est pas question que ConcurrentHashMap est thread-safe pour une seule opération, car vous n'deux opérations simples qui doivent être traités à l'unité, donc oui, ce bloc synchronisé est correcte et il pourrait être synchronisés par autre chose, par exemple this.

  5. 1

    Dans Java 8, vous devez être en mesure de remplacer la double vérification de verrouillage avec .computeIfAbsent:

    sequences.computeIfAbsent(table, k -> initializeHashMapKeyValue(k));
  6. 0

    Créer un fichier nommé dictionary.txt avec le contenu suivant:

    a
as
an
b
bat
ball

    Ici, nous avons:
    Nombre de mots commençant par "a": 3

    Nombre de mots commençant par "b": 3

    Total nombre de mots: 6

    Maintenant exécuter le programme suivant: java WordCount test_dictionary.txt 10

    public class WordCount {
String fileName;
public WordCount(String fileName) {
this.fileName = fileName;
}
public void process() throws Exception {
long start = Instant.now().toEpochMilli();
LongAdder totalWords = new LongAdder();
//Map<Character, LongAdder> wordCounts = Collections.synchronizedMap(new HashMap<Character, LongAdder>());
ConcurrentHashMap<Character, LongAdder> wordCounts = new ConcurrentHashMap<Character, LongAdder>();
Files.readAllLines(Paths.get(fileName))
.parallelStream()
.map(line -> line.split("\\s+"))
.flatMap(Arrays::stream)
.parallel()
.map(String::toLowerCase)
.forEach(word -> {
totalWords.increment();
char c = word.charAt(0);
if (!wordCounts.containsKey(c)) {
wordCounts.put(c, new LongAdder());
}
wordCounts.get(c).increment();
});
System.out.println(wordCounts);
System.out.println("Total word count: " + totalWords);
long end = Instant.now().toEpochMilli();
System.out.println(String.format("Completed in %d milliseconds", (end - start)));
}
public static void main(String[] args) throws Exception {
for (int r = 0; r < Integer.parseInt(args[1]); r++) {
new WordCount(args[0]).process();
}
}

    }

    Vous voir varient comme indiqué ci-dessous:

    {a=2, b=3}

    Total nombre de mots: 6

    Achevé en 77 millisecondes

    {a=3, b=3}

    Total nombre de mots: 6

    Maintenant en commentaire ConcurrentHashMap à la ligne 13, décommentez la ligne du dessus et exécutez à nouveau le programme.

    Vous voir déterministe compte.