**
Definición de mecanismo de falla rápida a prueba de fallas
**
Un mecanismo de error en la colección java (Colección). Cuando varios subprocesos operan en el contenido de la misma colección, puede ocurrir un evento de falla rápida. Por ejemplo: cuando un subproceso A atraviesa una colección a través del iterador, si el contenido de la colección es cambiado por otros subprocesos; entonces, cuando el subproceso A accede a la colección, se lanzará una ConcurrentModificationException y se generará un evento de falla rápida.
**
Mecanismo de falla rápida a prueba de fallas
**
1. En el caso de un solo hilo, cuando se usa un iterador para atravesar objetos, la estructura de la colección se modifica (agregando, eliminando y modificando elementos)
ArrayList<Integer> integers=new ArrayList<Integer>();
integers.add(2);
integers.add(1);
integers.add(null);
Iterator iterator=integers.iterator();
while (iterator.hasNext()){
Integer value= (Integer) iterator.next();
if (value.equals(2)){
integers.remove(value);
}
//integers.add(1);
}
2. En un entorno multiproceso, si el objeto de colección se modifica al mismo tiempo, se lanzará ConcurrentModificationException.
Razones para el mecanismo de falla rápida a prueba de fallas
Tome ArrayList como ejemplo, observe
la clase principal AbstractList de ArrayList y el código fuente del iterador ArrayList define un modCount
/**
* The number of times this list has been <i>structurally modified</i>.
* Structural modifications are those that change the size of the
* list, or otherwise perturb it in such a fashion that iterations in
* progress may yield incorrect results.
*
* <p>This field is used by the iterator and list iterator implementation
* returned by the {@code iterator} and {@code listIterator} methods.
* If the value of this field changes unexpectedly, the iterator (or list
* iterator) will throw a {@code ConcurrentModificationException} in
* response to the {@code next}, {@code remove}, {@code previous},
* {@code set} or {@code add} operations. This provides
* <i>fail-fast</i> behavior, rather than non-deterministic behavior in
* the face of concurrent modification during iteration.
*
* <p><b>Use of this field by subclasses is optional.</b> If a subclass
* wishes to provide fail-fast iterators (and list iterators), then it
* merely has to increment this field in its {@code add(int, E)} and
* {@code remove(int)} methods (and any other methods that it overrides
* that result in structural modifications to the list). A single call to
* {@code add(int, E)} or {@code remove(int)} must add no more than
* one to this field, or the iterators (and list iterators) will throw
* bogus {@code ConcurrentModificationExceptions}. If an implementation
* does not wish to provide fail-fast iterators, this field may be
* ignored.
*/
protected transient int modCount = 0;//记录list修改次数
El iterador ArrayList define un valor esperadoModCount = modCount.
Cuando se usa el iterador para acceder al objeto de la colección, si se modifica la estructura de la colección, se convertirá en modCount + 1, lo que hará que se esperaModCount! == modCount, lo que informa ConcurrentModificationException.
Tenga en cuenta que no se puede garantizar el comportamiento de falla rápida de los iteradores porque, en general, es imposible hacer garantías concretas sobre si se producen modificaciones concurrentes asíncronas. El iterador de falla rápida hará todo lo posible para lanzar ConcurrentModificationException. Por lo tanto, es incorrecto escribir un programa que se base en esta excepción para mejorar la corrección de este tipo de iterador: el comportamiento de falla rápida de los iteradores solo debe usarse para detectar errores.
Solución de mecanismo de falla rápida a prueba de fallas
1. Agregue la palabra clave sincronizada en el método de usar modCount, pero no se recomienda que el bloqueo de sincronización causado por la adición y eliminación pueda bloquear la operación transversal
2. Reemplace ArrayList con CopyOnWriteArrayList. Se recomienda utilizar este esquema
CopyOnWriteArrayList. La diferencia con ArrayList es que todas las operaciones variables de CopyOnWriteArrayList se implementan mediante una nueva copia de la matriz original, por lo que es seguro para subprocesos, y CopyOnWriteArrayList no informará ConcurrentModificationException al modificar la estructura en el iterador La sobrecarga causada por la clase es relativamente grande (copia de matriz). Pero es muy aplicable en ambos casos.
1. Cuando no puede o no desea realizar la sincronización transversal, pero necesita eliminar los conflictos de subprocesos concurrentes. 2. Cuando el número de operaciones transversales excede en gran medida el número de operaciones variables.
Iterator<Integer> iterator2=copyOnWriteArrayList.iterator();
while (iterator2.hasNext()){
int value=iterator2.next();
copyOnWriteArrayList.add(1);
}
Definición de mecanismo de falla de seguridad a prueba de fallas
A prueba de fallas Cualquier modificación a la estructura de la colección se modificará en una colección copiada, por lo que no se lanzará ConcurrentModificationException. La CopyOnWriteArrayList anterior es un mecanismo a prueba de fallas, y ConcurrentHashMap también es un mecanismo a
prueba de fallas. La ventaja de la protección contra fallas es que no reportará ConcurrentModificationException Las
desventajas son (1) la colección necesita ser copiada, lo que resulta en una gran cantidad de objetos inválidos, lo cual es costoso
(2) es imposible garantizar que los datos leídos sean los datos en el estructura de datos original.