Exception de modification simultanée

Si vous avez construit LinkedHashMap avec AccessOrder = True, LinkedHashMap.get () Mutate réellement le LinkedHashMap car il stocke l'entrée la plus récente accessible à l'avant de la liste liée des entrées. Peut-être que quelque chose appelle get () pendant que la liste des matrices effectue sa copie avec l'itérateur.

Je ne pense pas que votre Set () code> / get () code> est synchronisé contre le même moniteur que reconstruit () code> est. Cela permet à une personne d'appeler le jeu / gêner pendant que la ligne problématique est en cours d'exécution, en particulier lors de l'itération de l'ensemble clé de la clé de l'internaute lors de l'appel Addall () CODE> APPEL (Mise en œuvre interne exposée via votre pile Trace).

au lieu de créer SET () code> synchronisé, avez-vous essayé quelque chose dans le sens de: p> xxx pré>

Je ne pense pas Vous devez synchroniser get () code> du tout, mais si vous insistez: p> xxx pré>

En fait, je pense que vous feriez mieux de se synchroniser contre internalmap code> au lieu de ceci code>. Il n'a pas non plus mal de faire internalmap code> volatile code>, bien que je ne pense pas que cela soit vraiment nécessaire si vous êtes sûr que set () code > / get () code> / reconstruit () code> sont les seules méthodes accessibles directement à internalmap, et elles y accédent tous de manière synchronisée. P>

private volatile Map internalMap ...

En itérant sur les touches, en raison de xxx

Décidez-vous que certaines des entrées peuvent être supprimées du LinkedHashMap?

Le removeelDestEntry méthode pourrait être soit de retour vrai, soit la modification de la carte, contrarier ainsi l'itération.

Essayez de déclarer la carte comme transitoire

Essayez ceci:

public void rebuild(){
  /* initialization stuff */
  List<SomeKey> keysCopy = new ArrayList<SomeKey>();
  synchronized (internalMap) {
    keysCopy.addAll(internalMap.keySet());
  }
  /* 
    do stuff with keysCopy, update a temporary map
   */    
  synchronized (internalMap) {
    internalMap.putAll(tempMap);
  }
}

du Javadoc:

Si plusieurs threads accèdent simultanément une carte de hachage liée, et au moins une des threads modifie la carte structurellement, elle doit être synchronisée à l'extérieur. Ceci est généralement accompli en se synchronisant sur certains objets qui encapsulate naturellement la carte. Si aucun objet de ce type n'existe, la carte doit être "enveloppée" à l'aide de la méthode Collections.SynchronizedMap. Ceci est mieux fait au moment de la création, pour empêcher l'accès accidentel non synchronisé à la carte:

mappe m = collections.synchronizedMap (nouveau LinkedHashMap (...));

Il peut être plus sûr que vous puissiez réellement envelopper le LinkedHashMap plutôt que de prétendre que vous l'étendez. Votre implémentation aurait donc un élément de données interne qui est la carte renvoyée par Collections.SynchronizedMap (nouveau LinkedHashMap (...)).

S'il vous plaît voir les collections Javadoc pour plus de détails: Collections.SynchronizedMap

Gardez l'accès à internalmap Syncronisé , sinon Java.Util.ConCurrentModificationException a lieu car hashmap # modcount (qui enregistre les modifications structurelles) peut être modifiée simultanément pendant le keyset itération (attelé Keyscopy.Addall (internalmap.keyset ( ) Invocation).

LinkedHashMap Javadoc Spécifie: "Dans les cartes de hachage liées autorisées par accès, interroge simplement la carte avec get est une modification structurelle".