关于 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