java中的fail-safe和fail-fast

ArrayList<String> userNames = new ArrayList<>() {{
    add("tx");
    add("txtx");
    add("txtxtx");
    add("txtxtxtx");
}};

for(String name:userNames){
    if(name.equals("tx")){
        userNames.remove(name);
    }
}
System.out.println(userNames);

Exception in thread "main" java.util.ConcurrentModificationException
	at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1095)
	at java.base/java.util.ArrayList$Itr.next(ArrayList.java:1049)
	at org.tx.meituan818.main.main(main.java:15)

public class ArrayList<E> extends AbstractList<E> ...
    private class Itr implements Iterator<E> {
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

/**
 * 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 implementationreturned by the {@code iterator} and {@code listIterator} methods.If the value of this field changes unexpectedly, the iterator (or listiterator) will throw a {@code ConcurrentModificationException} inresponse 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 inthe face of concurrent modification during iteration.此字段由 and listIterator 方法返回iterator的迭代器和列表迭代器实现使用。如果此字段的值意外更改，则迭代器（或列表迭代器）将抛出一个ConcurrentModificationException 以响应 next、 remove、 previousset 或 add 操作。这提供了快速失败的行为，而不是在迭代过程中面对并发修改时的非确	 定性行为
 * <p><b>Use of this field by subclasses is optional.</b> If a subclasswishes to provide fail-fast iterators (and list iterators), then itmerely has to increment this field in its {@code add(int, E)} and{@code remove(int)} methods (and any other methods that it 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.
 子类使用此字段是可选的。 如果一个子类希望提供快速失败的迭代器（和列表迭代器），那么它只需要在其 add(int, E) 和 remove(int) 方法（以及它覆盖的导致对列表进行结构修改的任何其他方法）中增加此字段。对此 add(int, E) 字段的单个调用或 remove(int) 必须添加不超过一个，否则迭代器（和列表迭代器）将抛出虚假 ConcurrentModificationExceptions的 。如果实现不希望提供快速失败迭代器，则可以忽略此字段
 */
protected transient int modCount = 0;

public void remove() {
    if (lastRet < 0)
        throw new IllegalStateException();
    checkForComodification();

    try {
        ArrayList.this.remove(lastRet);
        cursor = lastRet;
        lastRet = -1;
        expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

public E remove(int index) {
    Objects.checkIndex(index, size);
    final Object[] es = elementData;

    @SuppressWarnings("unchecked") E oldValue = (E) es[index];
    fastRemove(es, index);

    return oldValue;
}

private void fastRemove(Object[] es, int i) {
    modCount++;
    final int newSize;
    if ((newSize = size - 1) > i)
        System.arraycopy(es, i + 1, es, i, newSize - i);
    es[size = newSize] = null;
}

Iterator<String> iterator = userNames.iterator();
while (iterator.hasNext()) {
    String name = iterator.next();
    if (name.equals("tx")) {
        iterator.remove();
    }
}
System.out.println(userNames);

#[txtx, txtxtx, txtxtxtx]

public boolean remove(Object o) {
    Object[] snapshot = getArray();
    int index = indexOfRange(o, snapshot, 0, snapshot.length);
    return index >= 0 && remove(o, snapshot, index);
}

/**
 * A version of remove(Object) using the strong hint that given
 * recent snapshot contains o at the given index.
 */
private boolean remove(Object o, Object[] snapshot, int index) {
    synchronized (lock) {
        Object[] current = getArray();
        int len = current.length;
        if (snapshot != current) findIndex: {
            int prefix = Math.min(index, len);
            for (int i = 0; i < prefix; i++) {
                if (current[i] != snapshot[i]
                    && Objects.equals(o, current[i])) {
                    index = i;
                    break findIndex;
                }
            }
            if (index >= len)
                return false;
            if (current[index] == o)
                break findIndex;
            index = indexOfRange(o, current, index, len);
            if (index < 0)
                return false;
        }
        Object[] newElements = new Object[len - 1];
        System.arraycopy(current, 0, newElements, 0, index);
        System.arraycopy(current, index + 1,
                         newElements, index,
                         len - index - 1);
        setArray(newElements);
        return true;
    }
}

List<String> userNames = new CopyOnWriteArrayList<>() {{
    add("tx");
    add("txtx");
    add("txtxtx");
    add("txtxtxtx");
}};
Iterator<String> iterator = userNames.iterator();
for(String name:userNames){
    if(name.equals("tx")){
        userNames.remove(name);
    }
}
System.out.println(userNames);
while(iterator.hasNext()){
    System.out.println(iterator.next());
}
Iterator<String> iterator1 = userNames.iterator();
while (iterator1.hasNext()){
    System.out.println(iterator1.next());
}

[txtx, txtxtx, txtxtxtx]
tx
txtx
txtxtx
txtxtxtx
txtx
txtxtx
txtxtxtx