ConcurrentModificationException anche con l'utilizzo di Collections.sychronizedMap su un LinkedHashMap

Question

sto usando un oggetto di mappa nella mia classe che ho sincronizzato con Collections.synchronizedMap() per un LinkedHashMap in questo modo:

private GameObjectManager(){ 
     gameObjects = Collections.synchronizedMap(new LinkedHashMap<String, GameObject>()); 
} 

Sono ottenere un'eccezione modifica simultanea nella terza riga di questa funzione:

public static void frameElapsed(float msElapsed){ 
    if(!INSTANCE.gameObjects.isEmpty()){ 
     synchronized(INSTANCE.gameObjects){ 
      for(GameObject object : INSTANCE.gameObjects.values()){...} 
     } 
    } 
} 

Tutti gli altri luoghi in cui sto scorrendo la mappa, si esegue la sincronizzazione sulla mappa per la documentazione.

Ci sono altre funzioni nella mia classe che usano questa mappa (quella sincronizzata!) E mettono oggetti() e remove(), ma questo non dovrebbe avere importanza. Che cosa sto facendo di sbagliato? Per favore chiedete altro codice, non sapete cos'altro mettere.

Oh, e il messaggio di log:

08-20 15:55:30.109: E/AndroidRuntime(14482): FATAL EXCEPTION: GLThread 1748 
08-20 15:55:30.109: E/AndroidRuntime(14482): java.util.ConcurrentModificationException 
08-20 15:55:30.109: E/AndroidRuntime(14482): at  java.util.LinkedHashMap$LinkedHashIterator.nextEntry(LinkedHashMap.java:350) 
08-20 15:55:30.109: E/AndroidRuntime(14482): at  java.util.LinkedHashMap$ValueIterator.next(LinkedHashMap.java:374) 
08-20 15:55:30.109: E/AndroidRuntime(14482): at  package.GameObjectManager.frameElapsed(GameObjectManager.java:247) 
08-20 15:55:30.109: E/AndroidRuntime(14482): at  package.GamekitInterface.render(Native Method) 
08-20 15:55:30.109: E/AndroidRuntime(14482): at  package.GamekitInterface.renderFrame(GamekitInterface.java:332) 
08-20 15:55:30.109: E/AndroidRuntime(14482): at  com.qualcomm.QCARSamples.ImageTargets.GameEngineInterface.onDrawFrame(GameEngineInterface.java:107) 
08-20 15:55:30.109: E/AndroidRuntime(14482): at  android.opengl.GLSurfaceView$GLThread.guardedRun(GLSurfaceView.java:1516) 
08-20 15:55:30.109: E/AndroidRuntime(14482): at  android.opengl.GLSurfaceView$GLThread.run(GLSurfaceView.java:1240) 

Answer 1

Nonostante il nome, questo non ha nulla a che fare con la concorrenza nel senso del multithreading. Non è possibile modificare questa mappa mentre si sta iterando su di essa, tranne invocando remove() sull'iteratore. Cioè, dove si hanno ...

for(GameObject object : INSTANCE.gameObjects.values()){...} 

se il ... modifica INSTANCE.gameObjects.values() (per esempio, la rimozione o l'aggiunta di un elemento), il successivo richiamo alla next() sul iteratore (che è implicita all'anello for) sarà getti quell'eccezione

Questo è vero per la maggior parte delle raccolte e implementazioni di mappe. I javadoc di solito specificano questo comportamento, anche se non sempre ovviamente.

Correzioni:

• Se state cercando di fare è rimuovere l'elemento, è necessario per ottenere in modo esplicito il Iterator<GameObject> e chiamare remove() su di esso.

  for (Iterator<GameObject> iter = INSTANCE.getObjects().values(); iter.hasNext(); ;) { 
      GameObject object = iter.next(); 
      if (someCondition(object)) { 
       iter.remove(); 
      } 
  } 
  

• Se stai cercando di aggiungere un elemento, è necessario creare una collezione temporanea per contenere gli elementi che si desidera aggiungere, e poi, dopo l'iteratore è finito, putAll(temporaryMapForAdding).

Answer 2

Collections.synchronizedMap() non aiuta quando l'iterazione. Ciò farà sì che la tua mappa esegua le operazioni put/get/remove atomicamente (ciò significa che non avrai due di queste operazioni in esecuzione simultaneamente).

Durante l'iterazione, si preleva ogni elemento e si fa qualcosa con esso. Ma cosa succede se lo stesso elemento su cui stai agendo all'interno della tua iterazione mentre il tuo elemento corrente viene rimosso da qualche altro thread?

Questo è ciò che l'eccezione sta cercando di impedire, in quanto potresti ottenere un risultato che non corrisponde ad alcuna istantanea reale della mappa: se stai calcolando la somma dei tuoi valori Integer, ad esempio, gli elementi hai già aggiunto che potresti essere rimosso e altri potrebbero essere aggiunti durante l'iterazione, quindi ti ritroverai con una somma che non corrisponde ad alcuna "istantanea" della tua mappa.

Per ciò che si sta tentando di fare, l'unica soluzione sarebbe quella di eseguire l'intera iterazione all'interno di un blocco sincronizzato ma è obbligatorio sincronizzarsi sullo stesso monitor utilizzato dalle operazioni della mappa. E lo Collections.syncrhonizedMap() fornisce un wrapper che si sincronizza su alcuni interni mutex, non su, numero this. Pertanto, il tentativo di impedire qualsiasi modifica alla tua mappa durante l'iterazione avrà esito negativo.

Answer 3

si utilizza for-each versione uguale di ciclo for. In Java è vietato aggiungere o rimuovere elementi dalla raccolta iterata in tale ciclo. Per evitare questa situazione, utilizzare l'iteratore di raccolte. Da iteratore, puoi rimuovere elementi.