1.Volley源碼分析（一）
2.Volley源碼分析（二）
3.Volley源碼分析（三）
4.XVolley-基于Volley的封裝的工具類
上一篇分析完了Volley.newRequestqueue()方法。方法最后執行到了requestqueue.start()方法
/**
* Starts the dispatchers in this queue.
*/
public void start() {
//停止當前所有線程
stop(); // Make sure any currently running dispatchers are stopped.
// Create the cache dispatcher and start it.
//創建一個緩沖線程，并start
mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
mCacheDispatcher.start();
// Create network dispatchers (and corresponding threads) up to the pool size.
//創建4個網絡請求線程
for (int i = 0; i < mDispatchers.length; i++) {
NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
mCache, mDelivery);
mDispatchers[i] = networkDispatcher;
networkDispatcher.start();
}
}
首先看stop方法
/**
* Stops the cache and network dispatchers.
*/
public void stop() {
if (mCacheDispatcher != null) {
mCacheDispatcher.quit();
}
for (final NetworkDispatcher mDispatcher : mDispatchers) {
if (mDispatcher != null) {
mDispatcher.quit();
}
}
}
可以看到，stop方法里將所有的線程都quit掉了。
stop方法執行完畢后，會創建一個CacheDispatcher對象和NetworkDispatcher對象的數組，這里先提前說明一下，這兩個對象都是繼承的Thread類（后面會單獨分析這兩個類）再通過名字就很好理解了，這里stop后會創建一個緩存線程和4個網絡線程，并調用start方法。
4個線程的來歷：可以看下RequestQueue是我們在創建RequestQueue時的構造方法,默認調用的是第一個構造方法，對應的DEFAULT_NETWORK_THREAD_POOL_SIZE=4
public RequestQueue(Cache cache, Network network) {
/**
* 默認線程池大小=4
*/
this(cache, network, DEFAULT_NETWORK_THREAD_POOL_SIZE);
}
public RequestQueue(Cache cache, Network network, int threadPoolSize) {
this(cache, network, threadPoolSize,
//Looper.getMainLooper()對應主線程，所以請求成功后的接口回調對應是在主線程中執行。
new ExecutorDelivery(new Handler(Looper.getMainLooper())));
}
public RequestQueue(Cache cache, Network network, int threadPoolSize,ResponseDelivery delivery) {
mCache = cache;
mNetwork = network;
mDispatchers = new NetworkDispatcher[threadPoolSize];
mDelivery = delivery;
}
分析完start方法，現在分析requestqueue的add方法。
public <T> Request<T> add(Request<T> request) {
// Tag the request as belonging to this queue and add it to the set of current requests.
request.setRequestQueue(this);
//mCurrentRequest是一個HashSet,不是線程安全的，所以進行加鎖操作，保證同時只能加一個
synchronized (mCurrentRequests) {
mCurrentRequests.add(request);
}
// Process requests in the order they are added.
//添加序列號，這里用到了AtomicInteger，是一個線程安全的Integer，適用于高并發的Integer加減
request.setSequence(getSequenceNumber());
//添加一個Log信息
request.addMarker("add-to-queue");
// If the request is uncacheable, skip the cache queue and go straight to the network.
//判斷request是否需要緩存，默認是需要的
if (!request.shouldCache()) {
//不需要緩存的話直接加入隊列，使用的是PriorityBlockingQueue---一個基于優先級堆的無界的并發安全的優先級隊列
mNetworkQueue.add(request);
return request;
}
// Insert request into stage if there's already a request with the same cache key in flight.
//mWaitingRequest 對應一個map<key,queue<request>>
synchronized (mWaitingRequests) {
//key對應著url
String cacheKey = request.getCacheKey();
if (mWaitingRequests.containsKey(cacheKey)) {
//如果已經有一個相同的請求已經在等待隊列里，則將現在這個請求放入相同key的等待隊列中
// There is already a request in flight. Queue up.
Queue<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);
//沒有則new一個
if (stagedRequests == null) {
stagedRequests = new LinkedList<>();
}
stagedRequests.add(request);
mWaitingRequests.put(cacheKey, stagedRequests);
if (VolleyLog.DEBUG) {
VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);
}
} else {
// Insert 'null' queue for this cacheKey, indicating there is now a request in
// flight.
//沒有的話則插入一個key-null的信息，當為null表明這個key對應的請求就這一個，由于需要緩存，則加入緩存隊列
mWaitingRequests.put(cacheKey, null);
mCacheQueue.add(request);
}
return request;
}
}
第一步：首先將request加入mCurrentRequests。這里注意：
mCurrentRequests是一個HashSet,HashSet底層是一個HashMap,所以不是線程安全的，這里為了線程安全，利用synchronized關鍵字實現了加鎖操作。
第二步：給request添加了序列號。
這里用到了AtomicInteger，是一個線程安全的Integer，適用于高并發的Integer加減
/**
* Gets a sequence number.
*/
public int getSequenceNumber() {
return mSequenceGenerator.incrementAndGet();
}
/**
* Atomically increments by one the current value.
*
* @return the updated value
*/
public final int incrementAndGet() {
return U.getAndAddInt(this, VALUE, 1) + 1;
}
可以看到，這里利用AtomicInteger，每次獲取的序列號的時候，增加1。
第三步：判斷request是否需要緩存,每一個新建的request默認都是需要緩存的，如果不需要，則需要顯式的調研request的setShouldCache方法。這里如果不需要緩存，則直接將request加入網絡請求隊列（如下代碼所示）。這里使用的是PriorityBlockingQueue---一個基于優先級堆的無界的并發安全的優先級隊列。
if (!request.shouldCache()) {
//不需要緩存的話直接加入隊列，使用的是PriorityBlockingQueue---一個基于優先級堆的無界的并發安全的優先級隊列
mNetworkQueue.add(request);
return request;
}
第四步：如果需要緩存，這里對應需要插入到兩個地方mWaitingRequests和mCacheQueue，這里由于mWaitingRequests是一個HashMap，所以同樣，需要通過synchronized關鍵字進行加鎖操作。這里分細一點看：
String cacheKey = request.getCacheKey();
if (mWaitingRequests.containsKey(cacheKey)) {
//如果已經有一個相同的請求已經在等待隊列里，則將現在這個請求放入相同key的等待隊列中
// There is already a request in flight. Queue up.
Queue<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);
//沒有則new一個
if (stagedRequests == null) {
stagedRequests = new LinkedList<>();
}
stagedRequests.add(request);
mWaitingRequests.put(cacheKey, stagedRequests);
if (VolleyLog.DEBUG) {
VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);
}
}
1）這里mWaitingRequest對應的數據結構是map<key,queue<request>>，key對應的是url。首先判斷mWaitingRequest中是否存在相同的url的request，如果存在，則取出存放這種url的requestqueue，存在這個url，但對應的queue為空，則new一個，并且將這個request加入queue,并將queue加入mWatingRequest。
else {
// Insert 'null' queue for this cacheKey, indicating there is now a request in
// flight.
//沒有的話則插入一個key-null的信息，當為null表明這個key對應的請求就這一個，由于需要緩存，則加入緩存隊列
mWaitingRequests.put(cacheKey, null);
mCacheQueue.add(request);
}
2）如果不存在，則插入一個key-null到mWaitingRequest中，并將這個請求加入mCacheQueue緩存隊列。
所以這里一個需要緩存的request進入情況就很好分析了，一個新的request加入進來，對應的，mWaitingRequest存放一個key-null。當同樣的一個url的request進入的時候，就會放到mWaitingRequest中等待，而這時候mWaitingRequest存在該url的隊列，只不過queue為null，這時候就會new一個新的queue放入mWaitingRequest,等下次有同樣的url進入的時候，就會直接加入這個隊列中等待。
