What is modcount in the source code? What's the effect

Where can I see it

stay ArrayList,LinkedList,HashMap And so on , Delete , We can always see modCount The figure of

What does it mean

modCount, It literally means the number of changes

But why record modCount And the number of changes ？
Did you find a public feature , All use modCount Attribute It's all thread unsafe
that , We can't help thinking ： This field is probably used to ensure thread safety

Read the source code , Only in The iterator corresponding to this data structure Only used in , With HashMap For example

How to use it

private abstract class HashIterator<E> implements Iterator<E> {
    
        Entry<K,V> next;        // next entry to return
        int expectedModCount;   // For fast-fail
        int index;              // current slot
        Entry<K,V> current;     // current entry

        HashIterator() {
    
            expectedModCount = modCount;
            if (size > 0) {
     // advance to first entry
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }

        public final boolean hasNext() {
    
            return next != null;
        }

        final Entry<K,V> nextEntry() {
    
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            if (e == null)
                throw new NoSuchElementException();

            if ((next = e.next) == null) {
    
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
            current = e;
            return e;
        }

        public void remove() {
    
            if (current == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Object k = current.key;
            current = null;
            HashMap.this.removeEntryForKey(k);
            expectedModCount = modCount;
        }
    }

As can be seen from the above code , At the beginning of an iterator, it will be given the object that calls the iterator modCount, If in the iterator traversal process , Once the object is found mcount And stored in iterators mcount Dissimilarity , Then throw the exception , It means that someone has modified it before I submit .

In fact, this is a kind of Java Unique rapid failure mechanism

Fail-Fast Mechanism

We know java.util.HashMap Not thread safe , So if there are other threads that have changed while using iterators map, So will throw ConcurrentModificationException, That's what's called fail-fast Strategy . This strategy is implemented in the source code through modCount Domain ,modCount As the name implies, the number of changes , Yes HashMap The content modification will increase this value , This value will be assigned to the iterator during iterator initialization expectedModCount. In the iteration process , Judge modCount Follow expectedModCount Whether it is equal or not , If it is not equal, it means that other threads have been modified Map： be aware modCount Declare as volatile, Ensure visibility of changes between threads .

So I'd like to suggest , When you traverse the non thread safe data structures , Try to use iterators