并发修改异常-子列表中列表迭代器的下一个操作中无法访问的情况

Question

Consider the snippet extracted from the list iterator of the sub list inside an arraylist

                @SuppressWarnings("unchecked")
                public E next() {
                    checkForComodification();
                    int i = cursor;
                    if (i >= SubList.this.size)
                        throw new NoSuchElementException();
                    Object[] elementData = ArrayList.this.elementData;
                    if (offset + i >= elementData.length)
                        throw new ConcurrentModificationException();
                    cursor = i + 1;
                    return (E) elementData[offset + (lastRet = i)];
                }

cursor initially is set to 0. Imagine the arraylist and its sub list as below-

el      original    sublist
0       a[0]
10      a[1]
20      a[2]        s[0]
30      a[3]        s[1]
40      a[4]        s[2]
50      a[5]        s[3]
60      a[6]        s[4]
70      a[7]
80      a[8]
90      a[9]

I see that the condition used in the above next method

if (offset + i >= elementData.length)
                            throw new ConcurrentModificationException();

will never hold true.

Because

1) If you perform an add operation to the sublist, it will internally call the add method on the main arraylist and increments its size by 1. After performing the adding operation on the main list, it will increments the sub list size. if the expansion is needed on the main list, it(internally backed up by an array ) will grow to the necessary size.

offset is the diff b/w the starting positions of the arraylist and sublist. Since the condition for i in the above snippet is already checked (i >= SubList.this.size ), the condition offset + i >= elementData.length is never going to be true.

2) Similarly for the remove operation. The backing array never shrinks. The removal is tracked by reducing the size by 1. And backing array length and size are two different things. size is not equal to backing array length.

/**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    private int size;

What am I missing. Please suggest.

Answer 1

The clue is ConcurrentModificationException rather than NoSuchElementException .

If another thread removes an element during execution of this code, the condition may be true.