并发容器-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.增加元素

 1 public boolean add(E e) {

 2     return al.addIfAbsent(e);

 3 }

 4

 5 -------------CopyOnWriteArrayList---------------------

 6 public boolean addIfAbsent(E e) {

 7     Object[] snapshot = getArray();

 8     // 查找元素是否已经在数组中存在，如果存在则直接返回false，否则调用addIfAbsent(e, snapshot)

 9     return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :

10         addIfAbsent(e, snapshot);

11 }

12 /**

13  * A version of addIfAbsent using the strong hint that given

14  * recent snapshot does not contain e.

15  */

16 private boolean addIfAbsent(E e, Object[] snapshot) {

17     final ReentrantLock lock = this.lock;

18     lock.lock();

19     try {

20         Object[] current = getArray();

21         int len = current.length;

22         if (snapshot != current) {

23             // Optimize for lost race to another addXXX operation

24             int common = Math.min(snapshot.length, len);

25             for (int i = 0; i < common; i++)

26                 if (current[i] != snapshot[i] && eq(e, current[i])) // 这里是判断common长度范围内是否有元素与e相等

27                     return false;

28             if (indexOf(e, current, common, len) >= 0)  // 这里是判断common长度范围外是否有元素与e相等

29                     return false;

30         }

31         Object[] newElements = Arrays.copyOf(current, len + 1);

32         newElements[len] = e;

33         setArray(newElements);

34         return true;

35     } finally {

36         lock.unlock();

37     }

38 }

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

3.删除元素

 1 public boolean remove(Object o) {

 2     return al.remove(o);

 3 }

 4

 5 -------------CopyOnWriteArrayList---------------------

 6 public boolean remove(Object o) {

 7     Object[] snapshot = getArray();

 8     int index = indexOf(o, snapshot, 0, snapshot.length);

 9     return (index < 0) ? false : remove(o, snapshot, index);

10 }

11 private boolean remove(Object o, Object[] snapshot, int index) {

12     final ReentrantLock lock = this.lock;

13     lock.lock();

14     try {

15         Object[] current = getArray();

16         int len = current.length;

17         // 如果当前CopyOnWriteArrayList对象al已经发生变化，则再次寻找索引

18         if (snapshot != current) findIndex: {

19             int prefix = Math.min(index, len);

20             // 从[0,prefix-1]区间内找是否存在o，找到则break

21             for (int i = 0; i < prefix; i++) {

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

23                     index = i;

24                     break findIndex;

25                 }

26             }

27             // 如果在[0,prefix -1]区间内没找到且index>=len，表示index超出当前长度，返回false

28             if (index >= len)

29                 return false;

30             // 这部操作是有些时候对象al发生变化，但没影响对应index位置元素。这样可以省掉一次遍历操作。

31             if (current[index] == o)

32                 break findIndex;

33             index = indexOf(o, current, index, len);

34             // 在[0,index-1],[index,index],[index,len-1]都没找到，返回false

35             if (index < 0)

36                 return false;

37         }

38         Object[] newElements = new Object[len - 1];

39         System.arraycopy(current, 0, newElements, 0, index);

40         System.arraycopy(current, index + 1,

41                          newElements, index,

42                          len - index - 1);

43         setArray(newElements);

44         return true;

45     } finally {

46         lock.unlock();

47     }

48 }

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

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

巴特西

并发容器-CopyOnWriteSet

最新文章

热门文章