一 特性

  • 对其进行修改操作和元素迭代操作都是底层创建一个拷贝数组进行的 写时拷贝策略

  • 使用ReentrantLock 独占锁保证同时只有一个线程对array进行修改

    二 属性

    1.   /** The array, accessed only via getArray/setArray.  存储数据数组*/
    2.   private transient volatile Object[] array;
    4.   /** The lock protecting all mutators 独占锁 */
    5.   final transient ReentrantLock lock = new ReentrantLock();

三添加

  1. //添加的时候使用独占锁 添加到新数组中 最后再把数组copy回去    
  2. public boolean add(E e) {
  3.         final ReentrantLock lock = this.lock;
  4.         lock.lock();
  5.         try {
  6.             Object[] elements = getArray();
  7.             int len = elements.length;
  8.             Object[] newElements = Arrays.copyOf(elements, len + 1);
  9.             newElements[len] = e;
  10.             setArray(newElements);
  11.             return true;
  12.         } finally {
  13.             lock.unlock();
  14.         }
  15.     }

四 删除

  1. //删除也是先copy数组 然后对copy的数组进行修改 最后再设置原数组   
  2. public E remove(int index) {
  3.         final ReentrantLock lock = this.lock;
  4.         lock.lock();
  5.         try {
  6.             Object[] elements = getArray();
  7.             int len = elements.length;
  8.             E oldValue = get(elements, index);
  9.             int numMoved = len - index - 1;
  10.             if (numMoved == 0)
  11.                 setArray(Arrays.copyOf(elements, len - 1));
  12.             else {
  13.                 Object[] newElements = new Object[len - 1];
  14.                 System.arraycopy(elements, 0, newElements, 0, index);
  15.                 System.arraycopy(elements, index + 1, newElements, index,
  16.                                  numMoved);
  17.                 setArray(newElements);
  18.             }
  19.             return oldValue;
  20.         } finally {
  21.             lock.unlock();
  22.         }
  23.     }

五 获取

  1.     public E get(int index) {
  2.         return get(getArray(), index);
  3.     }