LinkedList&CopyOnWriteArrayList源码分析

前言

由于LinkedList和CopyOnWriteArrayList的源码相对来说比较简单，就放在一起分析了。

LinkedList

就从下面一个例子开始分析

public static void main(String[] args) {    List<String> list = new LinkedList<String>();     List<String> l = new ArrayList<>() ;    list.add("java");    list.add("android");    l.add("c++");    l.add("python");    list.addAll(0,l);    System.out.println(list);}

首先看默认构造函数:

// 没有做其他处理public LinkedList() {}

再看add()方法

public boolean add(E e) {    linkLast(e);    return true;}

void linkLast(E e) {    final Node<E> l = last;    final Node<E> newNode = new Node<>(l, e, null);    // 让当前节点作为尾节点    last = newNode;    // 判断当前链表是否为null,如果为null,则新加节点为头节点    if (l == null)        first = newNode;    else        l.next = newNode;    size++;    modCount++;}

这里需要注意下Node，这就是链表中每个节点的数据结构，我们后面会分析很多集合，都会见到Node的影子。而add()方法就比较简单了，创建一个Node节点，然后就是做下判断，往后面添加了。

private static class Node<E> {    // 当前节点表示的值    E item;    // 下一节点    Node<E> next;    // 上一节点    Node<E> prev;    Node(Node<E> prev, E element, Node<E> next) {        this.item = element;        this.next = next;        this.prev = prev;    }}

再看下addAll()方法吧。

// index:表示要添加的位置public boolean addAll(int index, Collection<? extends E> c) {    // 检查集合要添加的位置是否合法    checkPositionIndex(index);    // 将集合转为数组    Object[] a = c.toArray();    // 获取数组长度    int numNew = a.length;    if (numNew == 0)        return false;    // pred:标记要添加元素的前一个位置元素;succ:对应index位置的元素    Node<E> pred, succ;    if (index == size) {        succ = null;        pred = last;    } else {        succ = node(index);        pred = succ.prev;    }    // 遍历数组,创建结点对象,判断要添加元素的前一个位置的元素是否为null,如果    // 为null,则第一个元素则为first,否则将其赋值个.next元素    for (Object o : a) {        @SuppressWarnings("unchecked") E e = (E) o;        Node<E> newNode = new Node<>(pred, e, null);        if (pred == null)            first = newNode;        else            pred.next = newNode;        pred = newNode;    }    // 元素添加完了之后,处理“切口处”    // 判断对应index元素是否为null,如果为null,则pred为最后一个元素,否则,对应index元素为最后添加元素的next    if (succ == null) {        last = pred;    } else {        pred.next = succ;        succ.prev = pred;    }    size += numNew;    modCount++;    return true;}

上面注释已经比较清楚了，学过数据结构的应该很容易看懂。

CopyOnWriteArrayList

我们都知道CopyOnWriteArrayList是并发包的一个类，它是线程安全的。我们可以一边遍历一边去删除该集合里面的元素。

底层数据结构也是一个object数组。

private transient volatile Object[] array;

public static void main(String[] args) {        List<String> list = new CopyOnWriteArrayList<String>() ;        list.add("java");        list.add("c");        list.add("c#");    }

我们先看构造函数

public CopyOnWriteArrayList() {     setArray(new Object[0]); }final void setArray(Object[] a) {    array = a;}

从这可以看出，默认构造函数给array一个大小为0的object数组。

再看add()方法吧

public boolean add(E e) {    // 使用类定义的锁,在同一个时刻只能执行add/remove/set其中的一个    final ReentrantLock lock = this.lock;    lock.lock();    try {        Object[] elements = getArray();        int len = elements.length;        Object[] newElements = Arrays.copyOf(elements, len + 1);        newElements[len] = e;        setArray(newElements);        return true;    } finally {        lock.unlock();    }}

从上面可以知道，我们每次调用一次add()方法，开始前上锁，然后都会进行一次数组的拷贝。（是否会有些性能问题呢？），最后释放锁。整个过程比较简单。（相对于并发Map来说真是很简单了）

我们再来看一个方法

public E remove(int index) {    final ReentrantLock lock = this.lock;    lock.lock();    try {        // 获取源数组        Object[] elements = getArray();        // 数组长度        int len = elements.length;        // 获取数组index对应的值        E oldValue = get(elements, index);        // 计算数组拷贝的长度        int numMoved = len - index - 1;        if (numMoved == 0)            setArray(Arrays.copyOf(elements, len - 1));        else {            // 创建新数组            Object[] newElements = new Object[len - 1];            // 将源数组0-index拷贝到新数组            System.arraycopy(elements, 0, newElements, 0, index);            // 将源数组index+1的长度为 numMoved的数据拷贝到新数组            System.arraycopy(elements, index + 1, newElements, index,                             numMoved);            setArray(newElements);        }        return oldValue;    } finally {        lock.unlock();    }}

上面重要的几行代码进行了注释，从上面看，每次调用remove方法，它也是会进行数组的拷贝。

再看set()方法

public E set(int index, E element) {        final ReentrantLock lock = this.lock;        lock.lock();        try {            Object[] elements = getArray();            E oldValue = get(elements, index);            if (oldValue != element) {                int len = elements.length;                Object[] newElements = Arrays.copyOf(elements, len);                newElements[index] = element;                setArray(newElements);            } else {                // Not quite a no-op; ensures volatile write semantics                setArray(elements);            }            return oldValue;        } finally {            lock.unlock();        }    }

上面代码比较简单，也是通过数组的拷贝来实现功能的。

总结

List系列简单就介绍到这里了，因为我们经常使用的也就这几个。其实我感觉，相对于Map系列，List系列的源码相对来说比较简单点了。不过其实还有几点不明白的地方。

• 为什么CopyOnWriteArrayList的set/remove/add等方法上锁代码不是this.lock.lock(),而非要来弄个引用指向？有心还是无意。

• CopyOnWriteArrayList的这些方法为什么要通过数组的拷贝来实现？不是已经有锁来保证了安全吗？这样做性能不是很低吗。

  还有些许疑点，欢迎指点。

从下篇开始分析Map系列的源码。