JDK1.8
ArrayList源碼分析--jdk1.8
LinkedList源碼分析--jdk1.8
HashMap源碼分析--jdk1.8
AQS源碼分析--jdk1.8
AbstractQueuedSynchronizer概述
1. AQS是一個基於FIFO隊列，可以用於構建鎖或者其他相關同步裝置的基礎框架。
2. AQS提供了雙向鏈表。
3. AQS分爲共享模式和獨佔模式。
4.AQS基於volatile內存可見性和CAS原子性操作實現線程間通信操作。
AbstractQueuedSynchronizer數據結構
數據結構是集合的精華所在，數據結構往往也限制了集合的作用和側重點，瞭解各種數據結構是我們分析源碼的必經之路。
AQS的數據結構如下：雙向鏈表
AQS實現共享資源的訪問控制基礎：
1.state字段，即同步器狀態字段。用於共享資源的訪問控制
2.CLH隊列，FIFO等待隊列，存放競爭失敗的線程。通常CLH隊列是一個自旋隊列，AQS以阻塞的方式實現
CLH隊列的使用：
CLH掃盲
自旋鎖
學習瞭解自旋鎖之前先回顧一下互斥鎖
互斥鎖
線程在獲取互斥鎖的時候，如果發現鎖已經被其它線程佔有，那麼線程就會驚醒休眠，然後在適當的時機（比如喚醒）在獲取鎖。
自旋鎖
那麼自旋鎖顧名思義就是“自旋”。就是當一個線程在嘗試獲取鎖失敗之後，線程不會休眠或者掛起，而是一直在循環檢測鎖是否被其它線程釋放。
區別
互斥鎖就是開始開銷要大於自旋鎖。臨界區持鎖時間的大小並不會對互斥鎖的開銷造成影響，而自旋鎖是死循環檢測，加鎖全程消耗cpu，起始開銷雖然低於互斥鎖，但是隨着持鎖時間，加鎖的開銷是線性增長。
適用的情況
互斥鎖用於臨界區持鎖時間比較長的操作，比如下面這些情況都可以考慮臨界區有IO操作
臨界區代碼複雜或者循環量大
臨界區競爭非常激烈
單核處理器
自旋鎖就主要用在臨界區持鎖時間非常短且CPU資源不緊張的情況下。當遞歸調用時有可能造成死鎖。
線程（節點）隊列
瞭解了自旋鎖之後，在學習ReentrantLock的時候，一個線程在等待鎖的時候會被封裝成一個Node節點，然後加入一個隊列中並檢測前一個節點是否是頭節點，並且嘗試獲取鎖，如果獲取鎖成功就返回，否則就阻塞。直到上一個節點釋放鎖並喚醒它。這樣看來似乎跟自旋沒什麼掛鉤。這是因爲AQS裏面的CLH隊列是CLH隊列鎖的一種變形。先來了解一下CLH隊列鎖
CLH隊列鎖
CLH(Craig, Landin, and Hagersten locks): 是一個自旋鎖，能確保無飢餓性，提供先來先服務的公平性。
CLH鎖也是一種基於鏈表的可擴展、高性能、公平的自旋鎖，申請線程只在本地變量上自旋，它不斷輪詢前驅的狀態，如果發現前驅釋放了鎖就結束自旋。http://www.2cto.com/kf/201412/363574.html這篇文章中有比較詳細的圖解。
AQS中的CLH隊列
瞭解了自旋鎖與CLH隊列鎖之後，在學習AQS中的CLH隊列就比較簡單了。AQS中的CLH隊列主要是對CLH隊列鎖改動了兩個地方
1.節點結構上做出改變。CLH隊列鎖的節點包含一個布爾類型locked的字段。如果要獲取鎖，就將這個locked設置爲true。然後就不停的輪訓前驅節點的locked是否釋放了鎖（這個過程我們就叫做自旋）。AQS的CLH隊列在結構上引入了頭節點，尾節點。並且擁有一個前節點與下一個節點的引用。
2.在等待獲取鎖的機制上由自旋改成了等待阻塞。
MCS
MSC與CLH最大的不同並不是鏈表是顯示還是隱式，而是線程自旋的規則不同:CLH是在前趨結點的locked域上自旋等待，而MSC是在自己的
結點的locked域上自旋等待。正因爲如此，它解決了CLH在NUMA系統架構中獲取locked域狀態內存過遠的問題。
AbstractQueuedSynchronizer源碼分析
/*
* 提供了一個基於FIFO隊列，可以用於構建鎖或者其他相關同步裝置的基礎框架
* 雙向鏈表
*/
public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements java.io.Serializable {
/**
* 無參構造方法
*/
protected AbstractQueuedSynchronizer() { }
/**
* <pre>
* +------+ prev +-----+ +-----+
* head | | <---- | | <---- | | tail
* +------+ +-----+ +-----+
* </pre>
*/
static final class Node {
/** Marker to indicate a node is waiting in shared mode 模式，分爲共享與獨佔 共享模式 */
static final Node SHARED = new Node();
/** Marker to indicate a node is waiting in exclusive mode 獨佔模式 */
static final Node EXCLUSIVE = null;
/** waitStatus value to indicate thread has cancelled
* 結點狀態 節點watiStatus的值
* CANCELLED，值爲1，終態，該節點被取消由於超時或中斷
* SIGNAL，值爲-1，表示當前節點的後繼節點包含的線程需要運行，也就是unpark，所以當前節點release或cancels時，必須unpark它的後繼節點
* CONDITION，值爲-2，表示當前節點在等待condition，也就是在condition隊列中 該節點處於條件隊列中，將不會被用於sync queue，直到節點狀態被設置爲0
* PROPAGATE，值爲-3，表示當前場景下後續的acquireShared能夠得以執行releaseShared應該被傳播到其他節點
* 值爲0，表示當前節點在sync隊列中，等待着獲取鎖
* */
static final int CANCELLED = 1;
/** waitStatus value to indicate successor's thread needs unparking */
static final int SIGNAL = -1;
/** waitStatus value to indicate thread is waiting on condition */
static final int CONDITION = -2;
/**
* waitStatus value to indicate the next acquireShared should
* unconditionally propagate
*/
static final int PROPAGATE = -3;
/**
* Status field, taking on only the values:
* SIGNAL: The successor of this node is (or will soon be)
* blocked (via park), so the current node must
* unpark its successor when it releases or
* cancels. To avoid races, acquire methods must
* first indicate they need a signal,
* then retry the atomic acquire, and then,
* on failure, block.
* CANCELLED: This node is cancelled due to timeout or interrupt.
* Nodes never leave this state. In particular,
* a thread with cancelled node never again blocks.
* CONDITION: This node is currently on a condition queue.
* It will not be used as a sync queue node
* until transferred, at which time the status
* will be set to 0. (Use of this value here has
* nothing to do with the other uses of the
* field, but simplifies mechanics.)
* PROPAGATE: A releaseShared should be propagated to other
* nodes. This is set (for head node only) in
* doReleaseShared to ensure propagation
* continues, even if other operations have
* since intervened.
* 0: None of the above
* 結點狀態
*/
volatile int waitStatus;
/**
* 前驅結點
*/
volatile Node prev;
/**
* 後繼結點
*/
volatile Node next;
/**
* 結點所對應的線程
*/
volatile Thread thread;
/**
* 下一個等待者
*/
Node nextWaiter;
/**
* 結點是否在共享模式下等待
*/
final boolean isShared() {
return nextWaiter == SHARED;
}
/**
* 獲取前驅結點，若前驅結點爲空，拋出異常
*/
final Node predecessor() throws NullPointerException {
// 保存前驅結點
Node p = prev;
if (p == null) // 前驅結點爲空，拋出異常
throw new NullPointerException();
else // 前驅結點不爲空，返回
return p;
}
// 無參構造函數
Node() { // Used to establish initial head or SHARED marker
}
// 構造函數
Node(Thread thread, Node mode) { // Used by addWaiter
this.nextWaiter = mode;
this.thread = thread;
}
// 構造函數
Node(Thread thread, int waitStatus) { // Used by Condition
this.waitStatus = waitStatus;
this.thread = thread;
}
}
/**
* CLH隊列中頭結點
*/
private transient volatile Node head;
/**
* CLH隊列中尾結點
*/
private transient volatile Node tail;
/**
* 同步狀態
* 多線程同步獲取資源成功，則state字段會自增；若有線程釋放資源，則state字段自減。
* 信號量 記錄該線程持有鎖的次數。 該線程每次釋放所 信號量 -1。 信號量爲零 代表 鎖被真正釋放
*/
private volatile int state;
/**
* @return current state value
*/
protected final int getState() {
return state;
}
/**
* @param newState the new state value
*/
protected final void setState(int newState) {
state = newState;
}
/**
* 使用unsafe的cas比較並且交換，保證原子性
*/
protected final boolean compareAndSetState(int expect, int update) {
// See below for intrinsics setup to support this
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
AbstractQueuedSynchronizer繼承和實現分析
AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer
1. AbstractOwnableSynchronizer是一個抽象類，實現了Serializable接口，定義了獨佔模式，設置和獲取獨佔模式下的線程Thread信息。
2.ArrayList實現了List<E>、RandomAccess、Cloneable、Serializable接口
1)List<E>接口，ArrayList既然繼承自AbstractList抽象類，而AbstractList已 經實現了List接口，那麼ArrayList類爲何還要再實現List接口呢？我們帶着疑問往下看：
public class Demo1 extends ArrayList {
public static void main(String[] args) {
//返回[]
System.out.println(Arrays.toString(Demo1.class.getInterfaces()));
}
public class Demo2 implements Serializable {
public static void main(String[] args) {
//返回[interface java.io.Serializable]
System.out.println(Arrays.toString(Demo2.class.getInterfaces()));
}
public class Test{
public static void main(String[] args) {
Serializable c1 = new Demo1();//未顯示實現接口
Serializable c2 = new Demo2();//顯示實現接口
Serializable proxy2 = createProxy(c2);
proxy2.foo();
Serializable proxy1 = createProxy(c1);
proxy1.foo();
}
private static <T> T createProxy(final T obj) {
final InvocationHandler handler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
return method.invoke(obj, args);
}
};
//實現接口代理，Demo1報錯，Demo2成功
//java.lang.ClassCastException: $Proxy1 cannot be cast to
//example.Test$Serializable
return (T) Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
.getClass().getInterfaces(), handler);
}可以看出這樣這樣設計是有道理的，因此，這並不是一個錯誤，很可能是作者Josh Bloch爲了便於實現代理而精心設計的。
參考與：開發collection 的作者Josh說
2)RandomAccess接口，這是一個標記接口，一般此標記接口用於 List 實現，以表明它們支持快速（通常是恆定時間）的隨機訪問，該接口的主要目的是允許通用算法改變其行爲，以便在應用於隨機或順序訪問列表時提供良好的性能，實現了該接口的話使用普通的for循環來遍歷，性能更高，而沒有實現該接口的話，使用Iterator來迭代，這樣性能更高，例如linkedList。所以這個標記性只是爲了讓我們知道我們用什麼樣的方式去獲取數據性能更好
3)Cloneable接口，可以使用Object.Clone()方法。
4)Serializable接口，序列化接口，表明該類可以被序列化，什麼是序列化？簡單的說，就是能夠從類變成字節流傳輸，反序列化，就是從字節流變成原來的類
ArrayList核心方法分析
1. add方法(4種重載實現)--增
1)add(E)；//默認直接在末尾添加元素
/**
* 新增元素
*/
public boolean add(E e) {
//賦值初始長度 或者擴容,新增元素，當前實際size+1的長度
ensureCapacityInternal(size + 1); // Increments modCount!!
//添加元素
elementData[size++] = e;
return true;
}
/**
* 確保elemenData數組有合適的大小
* 如果元素爲空，則複製長度默認爲10 或者更大
* @author jiaxiaoxian
* @date 2019年2月12日
*/
private void ensureCapacityInternal(int minCapacity) {
if (elementData == EMPTY_ELEMENTDATA) {//如果數組爲空，則從size+1的值和默認值10中取最大的
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
/**
* 確保elemenData數組有合適的大小
* @author jiaxiaoxian
* @date 2019年2月12日
* 如果長度大於元素長度則擴容
*/
private void ensureExplicitCapacity(int minCapacity) {
//記錄修改次數，迭代中不一致會觸發fail-fast機制,因此在遍歷中刪除元素的正確做法應該是使用Iterator.remove()
modCount++;
if (minCapacity - elementData.length > 0)
grow(minCapacity); //擴容
}
/**
* 擴容
*/
private void grow(int minCapacity) {
int oldCapacity = elementData.length; // 舊容量
int newCapacity = oldCapacity + (oldCapacity >> 1); // 新容量爲舊容量的1.5倍
if (newCapacity - minCapacity < 0) // 新容量小於參數指定容量，修改新容量
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0) // 新容量大於最大容量
newCapacity = hugeCapacity(minCapacity); // 指定新容量
// minCapacity is usually close to size, so this is a win: 拷貝擴容
elementData = Arrays.copyOf(elementData, newCapacity);
}
//如果小於0 就報錯，如果大於最大值 則取最大值
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}2)add(int index, E element)；//給指定下標，添加元素
/**
* 給指定下標，添加元素
*/
public void add(int index, E element) {
//判斷下標是否越界
rangeCheckForAdd(index);
//賦值初始長度 或者擴容
ensureCapacityInternal(size + 1); // Increments modCount!!
//將源數組中從index位置開始後的size-index個元素統一後移一位
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
//賦值
elementData[index] = element;
size++;
}
/**
* 判斷下標是否越界
*/
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
* src:源數組
* srcPos:源數組要複製的起始位置
* dest:目的數組
* destPos:目的數組放置的起始位置
* length:複製的長度
* 注意：src 和 dest都必須是同類型或者可以進行轉換類型的數組
*/
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);3)addAll(Collection<? extends E> c)；//添加Collection類型元素
/**
* 按照指定collection的迭代器所返回的元素順序，將該collection中的所有元素添加到此列表的尾部
*/
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
//將數組a[0,...,numNew-1]複製到數組elementData[size,...,size+numNew-1]
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}4)addAll(int index, Collection<? extends E> c)；//指定位置，添加Collection類型元素
/**
* 從指定的位置開始，將指定collection中的所有元素插入到此列表中，新元素的順序爲指定collection的迭代器所返回的元素順序
*/
public boolean addAll(int index, Collection<? extends E> c) {
//判斷下標是否越界
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
int numMoved = size - index;
//先將數組elementData[index,...,index+numMoved-1]複製到elementData[index+numMoved,...,index+2*numMoved-1]
//即，將源數組中從index位置開始的後numMoved個元素統一後移numNew位
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}總結：
正常情況下會擴容1.5倍，特殊情況下（新擴展數組大小已經達到了最大值）則只取最大值。
2.remove方法(4種重載實現)--刪
1)remove(int index); //根據指定下標 刪除元素
/**
* 根據指定下標 刪除元素
*/
public E remove(int index) {
//判斷索引是否越界
rangeCheck(index);
modCount++;
//獲取舊元素
E oldValue = elementData(index);
//將數組elementData中index位置之後的所有元素向前移一位
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//將原數組最後一個位置置爲null，由GC清理
elementData[--size] = null; // clear to let GC do its work
return oldValue;
} 2)remove(Object o); //根據指定元素 刪除元素
/**
* 移除ArrayList中首次出現的指定元素(如果存在)，ArrayList中允許存放重複的元素
*/
public boolean remove(Object o) {
// 由於ArrayList中允許存放null，因此下面通過兩種情況來分別處理。
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
//私有的移除方法，跳過index參數的邊界檢查以及不返回任何值
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
/*
* 根據下標快速刪除元素
*/
private void fastRemove(int index) {
modCount++;
//將數組elementData中index位置之後的所有元素向前移一位
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
}
/**
* 清空ArrayList，將全部的元素設爲null，等待垃圾回收將這個給回收掉，所以叫clear
*/
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
3)removeAll(Collection<?> c); //刪除包含在指定容器c中的所有元素
/**
* 刪除ArrayList中包含在指定容器c中的所有元素
*/
public boolean removeAll(Collection<?> c) {
//檢查指定的對象c是否爲空
Objects.requireNonNull(c);
return batchRemove(c, false);
}
/**
* 刪除全部
* @author jiaxiaoxian
* @date 2019年2月12日
*/
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0; //讀寫雙指針
boolean modified = false;
try {
for (; r < size; r++)
if (c.contains(elementData[r]) == complement) //判斷指定容器c中是否含有elementData[r]元素
elementData[w++] = elementData[r];
} finally {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) {
// clear to let GC do its work
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}4)removeIf(Predicate<? super E> filter); //按照一定規則過濾(刪除)集合中的元素
/**
* 按照一定規則過濾(刪除)集合中的元素
* 如：idList.removeIf(id -> id == nul);
* 去掉 List idList 集合中id 爲 null 的
* @param filter
* @return
*/
@Override
public boolean removeIf(Predicate<? super E> filter) {
Objects.requireNonNull(filter);
// figure out which elements are to be removed
// any exception thrown from the filter predicate at this stage
// will leave the collection unmodified
int removeCount = 0;
final BitSet removeSet = new BitSet(size);
final int expectedModCount = modCount;
final int size = this.size;
for (int i=0; modCount == expectedModCount && i < size; i++) {
@SuppressWarnings("unchecked")
final E element = (E) elementData[i];
if (filter.test(element)) {
removeSet.set(i);
removeCount++;
}
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
// shift surviving elements left over the spaces left by removed elements
final boolean anyToRemove = removeCount > 0;
if (anyToRemove) {
final int newSize = size - removeCount;
for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
i = removeSet.nextClearBit(i);
elementData[j] = elementData[i];
}
for (int k=newSize; k < size; k++) {
elementData[k] = null; // Let gc do its work
}
this.size = newSize;
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}
return anyToRemove;
}總結：
remove函數用戶移除指定下標的元素，此時會把指定下標到數組末尾的元素向前移動一個單位，並且會把數組最後一個元素設置爲null，這樣是爲了方便之後將整個數組不被使用時，會被GC，可以作爲小的技巧使用。
3.set方法--改
/**
* 覆蓋指定下標元素
*/
public E set(int index, E element) {
//判斷索引是否越界
rangeCheck(index);
//獲取舊元素
E oldValue = elementData(index);
//覆蓋爲新元素
elementData[index] = element;
//返回舊元素
return oldValue;
}
/**
* 判斷下標是否越界
*/
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}4.get方法--查
/**
* 返回指定索引的值
*/
public E get(int index) {
//判斷索引是否越界
rangeCheck(index);
return elementData(index);
}
/**
* @author jiaxiaoxian
* @date 2019年2月12日
* 返回下標元素的 值
*/
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}5.indexOf方法--查找下標
/**
* 查找下標， 如果爲null,直接和null比較，返回下標
*/
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
/**
* 查找最後出現的下標，從大往下循環查找
*/
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size-1; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}6.clone方法--克隆
/**
* 複製，返回此ArrayList 的淺拷貝
*/
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}7.trimToSize方法--刪除冗餘容量
/**
* 判斷數據實際容量大小，刪除自動增長後冗餘的容量
* 該方法用於回收多餘的內存。也就是說一旦我們確定集合不在添加多餘的元素之後，調用 trimToSize() 方法會將實現集合的數組大小剛好調整爲集合元素的大小。
* 注意：該方法會花時間來複制數組元素，所以應該在確定不會添加元素之後在調用
*/
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = Arrays.copyOf(elementData, size);
}
}8.Itr內部類--類似Iterator，可以幫我們對List進行遍歷，增刪改查等
/**
* 實例化一個Itr對象，並返回
*/
public Iterator<E> iterator() {
return new Itr();
}
/**
* 內部類，類似Iterator，可以幫我們對List進行遍歷，增刪改查等
*/
private class Itr implements Iterator<E> {
int cursor; // index of next element to return 下一個元素
int lastRet = -1; // index of last element returned; -1 if no such 當前元素
int expectedModCount = modCount; //modCount，就是爲了判斷是否有多個線程訪問修改
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
} 9.ListItr內部類--繼承了內部類Itr，還在此基礎上增加了向前遍歷，增加元素，更改元素內容等功能
/**
* 這個類繼承了內部類Itr
* 除了擁有上一個類的功能，還增加了向前遍歷，增加元素，更改元素內容等功能
*/
private class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
super();
cursor = index;
}
public boolean hasPrevious() {
return cursor != 0;
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor - 1;
}
@SuppressWarnings("unchecked")
public E previous() {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i;
return (E) elementData[lastRet = i];
}
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.set(lastRet, e);
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
public void add(E e) {
checkForComodification();
try {
int i = cursor;
ArrayList.this.add(i, e);
cursor = i + 1;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
} 10.SubList內部類--基於ArrayList建一個子集類
/**
* 雖然這個類很長，其實裏面的大部分方法調用都是ArrayList中的
* ListIterator在這個類中採用匿名內部類做了一點更改，不過也很類似
* 畢竟這個類就是根據ArrayList建一個子集類，就不贅述了
*/
private class SubList extends AbstractList<E> implements RandomAccess {
private final AbstractList<E> parent;
private final int parentOffset;
private final int offset;
int size;
SubList(AbstractList<E> parent,
int offset, int fromIndex, int toIndex) {
this.parent = parent;
this.parentOffset = fromIndex;
this.offset = offset + fromIndex;
this.size = toIndex - fromIndex;
this.modCount = ArrayList.this.modCount;
}
public E set(int index, E e) {
// 檢驗索引是否合法
rangeCheck(index);
//實現fail-fast機制 (迭代中不允許操作增刪改)
checkForComodification();
// 舊值
E oldValue = ArrayList.this.elementData(offset + index);
// 賦新值
ArrayList.this.elementData[offset + index] = e;
return oldValue;
}
public E get(int index) {
// 檢驗索引是否合法
rangeCheck(index);
//實現fail-fast機制 (迭代中不允許操作增刪改)
checkForComodification();
return ArrayList.this.elementData(offset + index);
}
public int size() {
checkForComodification();
return this.size;
}
public void add(int index, E e) {
rangeCheckForAdd(index);
checkForComodification();
parent.add(parentOffset + index, e);
this.modCount = parent.modCount;
this.size++;
}
public E remove(int index) {
rangeCheck(index);
checkForComodification();
E result = parent.remove(parentOffset + index);
this.modCount = parent.modCount;
this.size--;
return result;
}
protected void removeRange(int fromIndex, int toIndex) {
checkForComodification();
parent.removeRange(parentOffset + fromIndex,
parentOffset + toIndex);
this.modCount = parent.modCount;
this.size -= toIndex - fromIndex;
}
public boolean addAll(Collection<? extends E> c) {
return addAll(this.size, c);
}
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);
int cSize = c.size();
if (cSize==0)
return false;
checkForComodification();
parent.addAll(parentOffset + index, c);
this.modCount = parent.modCount;
this.size += cSize;
return true;
}
public Iterator<E> iterator() {
return listIterator();
}
public ListIterator<E> listIterator(final int index) {
checkForComodification();
rangeCheckForAdd(index);
final int offset = this.offset;
return new ListIterator<E>() {
int cursor = index;
int lastRet = -1;
int expectedModCount = ArrayList.this.modCount;
public boolean hasNext() {
return cursor != SubList.this.size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= SubList.this.size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (offset + i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[offset + (lastRet = i)];
}
public boolean hasPrevious() {
return cursor != 0;
}
@SuppressWarnings("unchecked")
public E previous() {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (offset + i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i;
return (E) elementData[offset + (lastRet = i)];
}
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = SubList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (offset + i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[offset + (i++)]);
}
// update once at end of iteration to reduce heap write traffic
lastRet = cursor = i;
checkForComodification();
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor - 1;
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
SubList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = ArrayList.this.modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.set(offset + lastRet, e);
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
public void add(E e) {
checkForComodification();
try {
int i = cursor;
SubList.this.add(i, e);
cursor = i + 1;
lastRet = -1;
expectedModCount = ArrayList.this.modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (expectedModCount != ArrayList.this.modCount)
throw new ConcurrentModificationException();
}
};
}
public List<E> subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, offset, fromIndex, toIndex);
}
private void rangeCheck(int index) {
if (index < 0 || index >= this.size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private void rangeCheckForAdd(int index) {
if (index < 0 || index > this.size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+this.size;
}
/**
* 實現fail-fast機制
* 線程不安全 迭代中不允許修改
* @author jiaxiaoxian
* @date 2019年2月12日
*/
private void checkForComodification() {
if (ArrayList.this.modCount != this.modCount)
throw new ConcurrentModificationException();
}
public Spliterator<E> spliterator() {
checkForComodification();
return new ArrayListSpliterator<E>(ArrayList.this, offset,
offset + this.size, this.modCount);
}
}11.ArrayListSpliterator內部類--並行迭代，基於索引的二分裂，懶惰初始化的Spliterator
/**
* @since 1.8
* 實例化一個ArrayListSpliterator對象，並返回
*/
@Override
public Spliterator<E> spliterator() {
return new ArrayListSpliterator<>(this, 0, -1, 0);
}
/**
* Index-based split-by-two, lazily initialized Spliterator
* 並行迭代
* 基於索引的二分裂，懶惰初始化的Spliterator
* */
static final class ArrayListSpliterator<E> implements Spliterator<E> {
private final ArrayList<E> list;
private int index; // current index, modified on advance/split
private int fence; // -1 until used; then one past last index
private int expectedModCount; // initialized when fence set
/** Create new spliterator covering the given range */
ArrayListSpliterator(ArrayList<E> list, int origin, int fence,
int expectedModCount) {
this.list = list; // OK if null unless traversed
this.index = origin;
this.fence = fence;
this.expectedModCount = expectedModCount;
}
private int getFence() { // initialize fence to size on first use
int hi; // (a specialized variant appears in method forEach)
ArrayList<E> lst;
if ((hi = fence) < 0) {
if ((lst = list) == null)
hi = fence = 0;
else {
expectedModCount = lst.modCount;
hi = fence = lst.size;
}
}
return hi;
}
public ArrayListSpliterator<E> trySplit() {
int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
return (lo >= mid) ? null : // divide range in half unless too small
new ArrayListSpliterator<E>(list, lo, index = mid,
expectedModCount);
}
public boolean tryAdvance(Consumer<? super E> action) {
if (action == null)
throw new NullPointerException();
int hi = getFence(), i = index;
if (i < hi) {
index = i + 1;
@SuppressWarnings("unchecked") E e = (E)list.elementData[i];
action.accept(e);
if (list.modCount != expectedModCount)
throw new ConcurrentModificationException();
return true;
}
return false;
}
public void forEachRemaining(Consumer<? super E> action) {
int i, hi, mc; // hoist accesses and checks from loop
ArrayList<E> lst; Object[] a;
if (action == null)
throw new NullPointerException();
if ((lst = list) != null && (a = lst.elementData) != null) {
if ((hi = fence) < 0) {
mc = lst.modCount;
hi = lst.size;
}
else
mc = expectedModCount;
if ((i = index) >= 0 && (index = hi) <= a.length) {
for (; i < hi; ++i) {
@SuppressWarnings("unchecked") E e = (E) a[i];
action.accept(e);
}
if (lst.modCount == mc)
return;
}
}
throw new ConcurrentModificationException();
}
public long estimateSize() {
return (long) (getFence() - index);
}
public int characteristics() {
return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
}
}ArrayList總結
1）arrayList可以存放null，本質是Object[]類型的數組。
2）arrayList區別於數組的地方在於能夠自動擴展大小，其中關鍵的方法就是gorw()方法。
3）arrayList由於本質是數組，所以它在數據的查詢方面會很快，而在插入刪除這些方面，性能下降很多，有移動很多數據才能達到應有的效果，而LinkedList則相反。
4）arrayList實現了RandomAccess，所以在遍歷它的時候推薦使用for循環。
5）初始化數組時推薦給初始長度，反覆擴容會增加時耗，影響性能效率。