[Java] explique ConcurrentModificationException qui se produit dans java.util.ArrayList pour les nouveaux arrivants

introduction

• C'est le 15e jour du Calendrier de l'Avent Stylez 2016.
• Dans notre entreprise, nous organisons des sessions d'étude sous forme de sessions de lecture pour les nouveaux arrivants (pour les débutants Java plutôt que pour les nouveaux venus) Veuillez vous référer à ce qui suit pour plus de détails.
• J'ai pensé à un livre d'apprentissage pour les programmeurs java (des nouveaux arrivants à environ 5 ans)
• L'histoire du démarrage d'une session de lecture sur Java pour les nouveaux arrivants
• [Java] explique le mystère de la sérialisation des Java Beans et des propriétés des champs pour les nouveaux arrivants avec des différences par rapport à POJO
• Je suis un conférencier pour les efforts ci-dessus, mais je reçois souvent des questions qui semblent être meilleures à poser dans le monde, alors j'écrirai les réponses à ces questions dans l'article.
• Cette fois, j'ai reçu l'exception ConcurrentModificationException lors du cours de qualification de [Java Programmer, Silver SE 8](http://www.oracle.com/jp/education/certification/jse8-2489021-ja.html) mené dans le même effort. À propos des questions liées à .

ConcurrentModificationException qui se produit également dans un seul thread

• C'est une histoire bien connue que java.util.ConcurrentModificationException se produit lorsqu'une instance java.util.ArrayList non thread-safe est modifiée à partir d'un autre thread, mais cela se produit également dans le traitement d'un seul thread. ..
• On m'a demandé qu'un tel problème soit posé dans divers examens simulés.
• Donc, à propos de ConcurrentModificationException qui se produit même dans un seul thread.
• En ce qui concerne le contenu, Exception n'est pas levée dans les cas suivants.

DenaiConcurrentModificationException.java

public static void main(String[] args) {
	List<String> list = new ArrayList<String>();
	
	list.add("A");
	list.add("B");
	list.add("C");
	list.add("D");
	
	for (String str : list) {
		if ("C".equals(str)) {
			list.remove(str);
		} else {
			System.out.println(str);
		}
	}
}

• Dans ce cas, ConcurrentModificationException sera levé.

DeruConcurrentModificationException.java

public static void main(String[] args) {
	List<String> list = new ArrayList<String>();
	
	list.add("A");
	list.add("B");
	list.add("C");
	list.add("D");
	list.add("E");
	
	for (String str : list) {
		if ("C".equals(str)) {
			list.remove(str);
		} else {
			System.out.println(str);
		}
	}
}

Quand une ConcurrentModificationException se produit-elle?

• Quant à savoir comment poser des questions, l'un des codes ci-dessus sera décrit, et quel en sera le résultat? Ce sera le contenu tel que.
• Le point de vue est de savoir si «ConcurrentModificationException» est lancée ou non. En guise de préparation de test approximative, si vous supprimez l'avant-dernier ou le dernier élément de la liste, il sera renvoyé "non fait", sinon il sera "fait".
• C'est juste ce qui précède, alors jetons un coup d'œil au doc et au code.

Documentation sur Java 8 SE ConcurrentModificationException

• Classe ConcurrentModificationException

Cette exception est levée lorsqu'une méthode qui détecte une modification parallèle dans un objet ne permet pas une telle modification.
Par exemple, il n'est généralement pas autorisé à un autre thread de modifier la collection pendant qu'un thread itère sur la collection.
Dans un tel environnement, les résultats du traitement itératif ne sont généralement pas garantis.
Quelques itérateurs(Iterator)Implémentation de(JREが提供するすべての一般的な目的のコレクションImplémentation deの、イテレータImplémentation deを含む)Est
Vous pouvez choisir de lever cette exception si ce comportement est détecté.
L'itérateur qui lève cette exception est appelé l'itérateur failfast.
Les itérateurs lancent des exceptions immédiatement et gracieusement pour éviter le risque de comportement imprévisible à des moments imprévisibles dans le futur.

• En bref, si un changement d'un autre thread est détecté pendant le traitement itératif, il sera lancé.
• Est-ce que le "Failfast Iterator" dans le texte échoue tôt? Cela ne signifie pas qu'il s'agit d'un itérateur qui déclenche immédiatement une exception et interrompt le traitement lorsqu'il existe une possibilité de modifications inattendues.
• L'exception pour un seul thread n'est pas mentionnée ici, je vais donc la lire un peu plus.

Cette exception n'indique pas nécessairement que l'objet n'a pas été mis à jour en parallèle par un autre thread.
L'objet lève cette exception si un seul thread émet un ensemble de méthodes qui violent les conventions de l'objet.
Par exemple, si un thread modifie une collection directement lors de l'itération sur une collection avec un itérateur failfast.
L'itérateur lève cette exception.

• Premièrement, java.util.ArrayList est un itérateur failfast. Il semble qu'une ConcurrentModificationException soit toujours lancée quand un thread modifie une collection directement en itérant avec *.
• Mais cela n'arrive pas dans certains cas ... alors jetons un œil à l'implémentation.

Jetez un œil à l'implémentation de java.util.ArrayList

• Tout d'abord, vous pouvez voir que la boucle for étendue utilise un itérateur en interne.

java

/**
 * An optimized version of AbstractList.Itr
 */
private class Itr implements Iterator<E> {}

Avec *, ConcurrentModificationException est levée s'il y a une différence entre expectedModCount et modCount à chaque fois que le curseur se déplace. Vous pouvez deviner le rôle de la propriété à partir du nom.

java

final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

• Si vous lisez plus loin, vous pouvez voir que remove incrémente modCount, ce qui provoque ConcurrentModificationException.

java

/*
 * Private remove method that skips bounds checking and does not
 * return the value removed.
 */
private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

• En vous concentrant sur System.arraycopy (elementData, index + 1, elementData, index, numMoved);, vous pouvez voir que lorsque l'élément C est supprimé, l'élément suivant est déplacé vers le haut comme indiqué ci-dessous.

• Comme le montre la figure ci-dessus, l'élément est déplacé vers le haut et le curseur ne change pas, donc l'élément 3 est traité après list.remove (" C "). Puisque 3 n'existe pas dans la première étape, le traitement se termine tel quel, le traitement se poursuit dans la deuxième étape, checkForComodification est exécuté et une ConcurrentModificationException est lancée.

Résumé

• Je l'ai écrit avec copier-coller, mais vous pouvez le comprendre en regardant l'implémentation et le débogage.
• Pendant le cours de qualification, j'ai débogué et obtenu la réponse. ..