關於 CopyOnWriteArrayList remove(Object o)方法的疑問記錄

 

源碼如下

    /**
     * Removes the first occurrence of the specified element from this list,
     * if it is present.  If this list does not contain the element, it is
     * unchanged.  More formally, removes the element with the lowest index
     * {@code i} such that
     * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>
     * (if such an element exists).  Returns {@code true} if this list
     * contained the specified element (or equivalently, if this list
     * changed as a result of the call).
     *
     * @param o element to be removed from this list, if present
     * @return {@code true} if this list contained the specified element
     */
    public boolean remove(Object o) {
        //保存數組快照
        Object[] snapshot = getArray();
        //獲得要查找對象的索引
        //這個步驟無鎖，是為了減小鎖的粒度，提高並發度
        int index = indexOf(o, snapshot, 0, snapshot.length);
        //根據索引，從數組移除對象
        return (index < 0) ? false : remove(o, snapshot, index);
    }

    /**
     * static version of indexOf, to allow repeated calls without
     * needing to re-acquire array each time.
     * @param o element to search for
     * @param elements the array
     * @param index first index to search
     * @param fence one past last index to search
     * @return index of element, or -1 if absent
     */
    private static int indexOf(Object o, Object[] elements,
                               int index, int fence) {
        if (o == null) {
            for (int i = index; i < fence; i++)
                if (elements[i] == null)
                    return i;
        } else {
            for (int i = index; i < fence; i++)
                if (o.equals(elements[i]))
                    return i;
        }
        return -1;
    }

    /**
     * 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) {
        //進入這個方法有個默認條件，snapshot[index] == o
        //而這里要考慮多線程的情況，即原有的數組可能已經被其他線程修改了，snapshot已經是過時的數據
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //獲取最新數組數據
            Object[] current = getArray();
            int len = current.length;
            if (snapshot != current) findIndex: {
                //考慮數組數據已經被其他線程修改了的情況，要重新定位index值
                int prefix = Math.min(index, len);
                //遍歷數組，從0到min(index, len)，查找o的index
                for (int i = 0; i < prefix; i++) {
                    if (current[i] != snapshot[i] && eq(o, current[i])) {
                        index = i;
                        break findIndex;
                    }
                }
                if (index >= len)
                    return false;
                if (current[index] == o)
                    break findIndex;
                index = indexOf(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;
        } finally {
            lock.unlock();
        }
    }

不明白的地方在於從60行開始，到77行為止，也就是findIndex 這個功能。

其進入條件是快照數組和當前數組不相等，即其他線程對數組進行了修改的操作，所以需要重新查找index值。在我理解，只需要三行代碼就可以解決了，如下：

index = indexOf(o, current, 0, len);
if (index < 0)
    return false;

這個方法是內部實現好的，直接調用飢渴獲取到current，即新數組的o對象對應的index值。

而源碼的那種實現我就不太懂了。尤其是循環里面的邏輯：

if (current[i] != snapshot[i] && eq(o, current[i])) 

這個判斷是處於什么考慮，想破腦袋還是不明白。先記錄下來。

TODO