并发容器-CopyOnWriteSet

CopyOnWriteSet

　　该容器与CopyOnWriteArrayList相似，也是读取时不加锁，任意线程可以读。写入时加锁创建一个新的容器，然后写入新元素。

　　内部用CopyOnWriteArrayList存储元素

private final CopyOnWriteArrayList<E> al;

1.判断元素是否存在

直接遍历al中的数组，查看是否有相等元素。

这里可以看出该容器是可以存放null的。

**
 * Returns {@code true} if this set contains the specified element.
 * More formally, returns {@code true} if and only if this set
 * contains an element {@code e} such that
 * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
 *  
 * @param o element whose presence in this set is to be tested
 * @return {@code true} if this set contains the specified element
 */
public boolean contains(Object o) {
    return al.contains(o);
}

-------------CopyOnWriteArrayList---------------------
/**
 * Returns {@code true} if this list contains the specified element.
 * More formally, returns {@code true} if and only if this list contains
 * at least one element {@code e} such that
 * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
 *
 * @param o element whose presence in this list is to be tested
 * @return {@code true} if this list contains the specified element
 */
public boolean contains(Object o) {
    Object[] elements = getArray();
    return indexOf(o, elements, 0, elements.length) >= 0;
}

2.增加元素

public boolean add(E e) {
    return al.addIfAbsent(e);
}

-------------CopyOnWriteArrayList---------------------
public boolean addIfAbsent(E e) {
    Object[] snapshot = getArray();
    // 查找元素是否已经在数组中存在，如果存在则直接返回false，否则调用addIfAbsent(e, snapshot)
    return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
        addIfAbsent(e, snapshot);
}
/**
 * A version of addIfAbsent using the strong hint that given
 * recent snapshot does not contain e.
 */
private boolean addIfAbsent(E e, Object[] snapshot) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] current = getArray();
        int len = current.length;
        if (snapshot != current) {
            // Optimize for lost race to another addXXX operation
            int common = Math.min(snapshot.length, len);
            for (int i = 0; i < common; i++)
                if (current[i] != snapshot[i] && eq(e, current[i])) // 这里是判断common长度范围内是否有元素与e相等
                    return false;
            if (indexOf(e, current, common, len) >= 0)  // 这里是判断common长度范围外是否有元素与e相等
                    return false;
        }
        Object[] newElements = Arrays.copyOf(current, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

addIfAbsent(E e)方法内不直接lock然后进行判断。我的理解：是为了减少对性能的影响，对于已经set中已经存在该值的情况可以不加锁，只有不包含时才会进行同步。

 

3.删除元素

public boolean remove(Object o) {
    return al.remove(o);
}

-------------CopyOnWriteArrayList---------------------
public boolean remove(Object o) {
    Object[] snapshot = getArray();
    int index = indexOf(o, snapshot, 0, snapshot.length);
    return (index < 0) ? false : remove(o, snapshot, index);
}
private boolean remove(Object o, Object[] snapshot, int index) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] current = getArray();
        int len = current.length;
        // 如果当前CopyOnWriteArrayList对象al已经发生变化，则再次寻找索引
        if (snapshot != current) findIndex: {
            int prefix = Math.min(index, len);
            // 从[0,prefix-1]区间内找是否存在o，找到则break
            for (int i = 0; i < prefix; i++) {
                if (current[i] != snapshot[i] && eq(o, current[i])) {
                    index = i;
                    break findIndex;
                }
            }
            // 如果在[0,prefix -1]区间内没找到且index>=len，表示index超出当前长度，返回false
            if (index >= len)
                return false;
            // 这部操作是有些时候对象al发生变化，但没影响对应index位置元素。这样可以省掉一次遍历操作。    
            if (current[index] == o)
                break findIndex;
            index = indexOf(o, current, index, len);
            // 在[0,index-1],[index,index],[index,len-1]都没找到，返回false
            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();
    }
}

　　这里是直接判断是否在al中存在，不存在返回false，存在则执行al的删除操作。当然删除时也是加锁，然后再次进行是否存在的判断，并进行删除的逻辑操作。

不在remove(Object o)处加锁，而是宁愿后续再检测list是否发生变化，也是基于性能考虑。使得对存在的元素进行remove操作时不用加锁。