Que sont les iterators à sécurité insortingnsèque et à défaillance rapide en Java

Il existe deux types d’iterators en Java: sécurité intégrée et restauration rapide.

Qu’est-ce que cela signifie, et est la différence entre eux?

Quelle est la différence entre eux …

“Fail safe” signifie: cela n’échouera pas. Ssortingctement parlant, Java n’existe pas en tant qu’iterator de sécurité. Le terme correct est “faiblement cohérent”. Le javadoc dit:

“La plupart des implémentations de collections simultanées (y compris la plupart des files d’attente) diffèrent également des conventions java.util habituelles en ce que leurs iterators et leurs diviseurs fournissent une traversée peu cohérente plutôt que rapide.”

En règle générale, la cohérence faible signifie que si une collection est modifiée en même temps qu’une itération, les garanties de ce que voit l’itération sont plus faibles. (Les détails seront spécifiés dans chaque javadocs de classes de collection de conncurrent.)

“Échec rapide” signifie: il peut échouer … et la condition de défaillance est vérifiée de manière agressive afin que la condition de défaillance soit (si possible 1 ) détectée avant que des dommages puissent être causés. En Java, un iterator rapide échoue en lançant une ConcurrentModificationException .

L’alternative à “échec rapide” et “faiblement cohérente” est une sémantique où l’itération échoue de manière imprévisible; par exemple, donner parfois la mauvaise réponse ou lancer une exception totalement inattendue. (C’était le comportement de certaines implémentations standard de l’API d’ Enumeration dans les premières versions de Java.)

… et sont-ils différents de l’iterator que nous utilisons pour la collecte.

Non. Ce sont les propriétés des iterators implémentées par les types de collection standard. c’est à dire qu’ils sont soit “échec rapide”, soit “faiblement cohérent” … lorsqu’ils sont utilisés correctement par rapport à la synchronisation et au modèle de mémoire Java 1 .


Les iterators rapides sont généralement implémentés à l’aide d’un compteur volatile sur l’object de collection.

  • Lorsque la collection est mise à jour, le compteur est incrémenté.
  • Lorsqu’un Iterator est créé, la valeur actuelle du compteur est intégrée à l’object Iterator .
  • Lorsqu’une opération d’ Iterator est effectuée, la méthode compare les deux valeurs de compteur et lance un CME s’ils sont différents.

L’implémentation d’iterators à sécurité intégrée est généralement légère. Ils reposent généralement sur les propriétés des structures de données de l’implémentation de liste spécifique. Il n’y a pas de schéma général. (Lisez le code source des classes de collection spécifiques qui vous intéressent.)


1 – Le rider est que le comportement rapide suppose que l’application est correctement identifiée par rapport à la synchronisation et au modèle de mémoire. Cela signifie que (par exemple) si vous effectuez une itération ArrayList sans une synchronisation correcte, le résultat final peut être un résultat corrompu. Le mécanisme “échec rapide” détectera probablement la modification simultanée (bien que cela ne soit pas garanti), mais ne détectera pas la corruption sous-jacente. Par exemple, javadoc pour Vector.iterator() dit ceci:

“Le comportement rapide d’un iterator ne peut pas être garanti car il est généralement impossible de faire des garanties en présence de modifications simultanées non synchronisées. Les iterators rapides donnent une exception de ConcurrentModificationException . avoir tort d’écrire un programme qui dépend de cette exception pour sa correction: le comportement rapide des iterators ne devrait être utilisé que pour détecter les bogues. “

Ce sont des types plutôt rapides et faiblement cohérents :

Les iterators du package java.util lancent une exception ConcurrentModificationException si la collection a été modifiée par les méthodes de collecte (add / remove) lors de l’itération

Les iterators du package java.util.concurrent généralement une itération sur un instantané et autorisent des modifications simultanées, mais peuvent ne pas refléter les mises à jour de la collection après la création de l’iterator.

La seule différence est que l’iterator à sécurité intégrée ne lance aucune exception, contrairement à l’iterator à défaillance rapide.

Si Collection est modifiée structurellement alors qu’un thread est itéré par dessus. C’est parce qu’ils fonctionnent sur le clone de Collection au lieu de la collection originale et c’est pourquoi ils sont appelés en tant qu’iterator de sécurité.

L’iterator de CopyOnWriteArrayList est un exemple d’iterator à sécurité intégrée également iterator écrit par ConcurrentHashMap