前言
由于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系列的源码。