Java ConcurrentHashMap atomique get si présent

Question

Comment effectuer une opération sécurisée en cas d'opération sur une carte de hachage concomitante? (Même chose comme putIfAbsent)

exemple Bad, pas très thread-safe (cocher agir alors la situation):

ConcurrentMap<String, SomeObject> concMap = new ... 

//... many putIfAbsent and remove operations 

public boolean setOption(String id, Object option){ 
    SomeObject obj = concMap.get(id); 

    if (obj != null){ 
     //what if this key has been removed from the map? 
     obj.setOption(option); 
     return true; 
    } 

    // in the meantime a putIfAbsent may have been called on the map and then this 
    //setOption call is no longer correct 

    return false; 
} 

Un autre mauvais exemple serait:

public boolean setOption(String id, Object option){ 
     if (concMap.contains(id)){ 
      concMap.get(id).setOption(option); 
      return true; 
     } 
     return false; 
    } 

La chose souhaitable est ici pas goulot d'étranglement l'ajout, supprimer et obtenir des opérations en les synchronisant.

Merci

Answer 1

Ce que vous semblez essayer de faire est de verrouiller une clé sur plusieurs opérations. Seule chaque opération est atomique. Ce n'est pas un moyen simple de verrouiller une clé, seulement pour verrouiller la carte. Toutefois, dans le cas "que se passe-t-il si je supprime une clé", tout ce que vous pouvez faire est de retarder l'opération de suppression jusqu'à ce que setOption soit appelée. Le résultat devrait être le même.

Vous semblez essayer de résoudre un problème qui n'a pas besoin d'être résolu. Vous n'avez pas expliqué pourquoi appeler setOption après la suppression d'une clé ou la suppression de la clé est incorrect.

Answer 2

Ne pas utiliser containsKey/get, il suffit d'appeler get. Si cette méthode renvoie null alors la clé n'était pas présente sinon la clé était présente, et vous avez obtenu la valeur à laquelle elle était mappée au moment du get.

De la documentation:

Renvoie la valeur à laquelle la clé spécifiée est mappée ou null si cette carte ne contient pas de correspondance pour la clé.

Voici comment votre deuxième exemple devrait ressembler à:

public boolean setOption(String id, Object option) { 

    SomeObject opt = concMap.get(id); 
    if (opt == null) 
     return false; 

    opt.setOption(option); 
    return true; 
} 

Answer 3

La méthode get() sur un ConcurrentHashMap est atomique. Puisque cette carte n'autorise pas les valeurs nulles, get() implémente "get if present": Si le résultat est null, la clé n'était pas présente.

Answer 4

Si vous devez effectuer plusieurs opérations sur une seule touche à ConcurrentMap, vous pouvez utiliser striping verrouillage technique pour réduire les conflits, voici un exemple avec le cadre Goyave:

private Striped<Lock> lock; 
    public boolean setOption(String id, Object option) { 
     try { 
     Lock lock = concMap.get(id); 
     lock.lock(); 
      if (concMap.contains(id)){ 
      concMap.get(id).setOption(option); 
     return true; 
    } 
    return false; 
     } finally { 
     lock.unlock(); 
     } 
    } 

Ou, depuis Java 8 : ConcurrentMap.compute est une nouvelle méthode atomique, voir comment il se fait sur une clé:

concMap.compute(keyId, (key, value) -> { 
    dosmth; ... return key; }); 

ps Les variantes possibles sont avec ConcurrentMap.computeIfPresent(), etc.