1.Volley源碼分析（一）
2.Volley源碼分析（二）
3.Volley源碼分析（三）
4.XVolley-基于Volley的封裝的工具類
上一篇分析完了Volley.newRequestqueue()方法。方法最后執(zhí)行到了requestqueue.start()方法
/**
* Starts the dispatchers in this queue.
*/
public void start() {
//停止當(dāng)前所有線程
stop(); // Make sure any currently running dispatchers are stopped.
// Create the cache dispatcher and start it.
//創(chuàng)建一個緩沖線程，并start
mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
mCacheDispatcher.start();
// Create network dispatchers (and corresponding threads) up to the pool size.
//創(chuàng)建4個網(wǎng)絡(luò)請求線程
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方法執(zhí)行完畢后全封，會創(chuàng)建一個CacheDispatcher對象和NetworkDispatcher對象的數(shù)組坑夯，這里先提前說明一下狼渊，這兩個對象都是繼承的Thread類（后面會單獨分析這兩個類）再通過名字就很好理解了拴念，這里stop后會創(chuàng)建一個緩存線程和4個網(wǎng)絡(luò)線程氧映，并調(diào)用start方法春畔。
4個線程的來歷：可以看下RequestQueue是我們在創(chuàng)建RequestQueue時的構(gòu)造方法,默認(rèn)調(diào)用的是第一個構(gòu)造方法，對應(yīng)的DEFAULT_NETWORK_THREAD_POOL_SIZE=4
public RequestQueue(Cache cache, Network network) {
/**
* 默認(rèn)線程池大小=4
*/
this(cache, network, DEFAULT_NETWORK_THREAD_POOL_SIZE);
}
public RequestQueue(Cache cache, Network network, int threadPoolSize) {
this(cache, network, threadPoolSize,
//Looper.getMainLooper()對應(yīng)主線程岛都，所以請求成功后的接口回調(diào)對應(yīng)是在主線程中執(zhí)行律姨。
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方法，現(xiàn)在分析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，適用于高并發(fā)的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是否需要緩存鸽斟，默認(rèn)是需要的
if (!request.shouldCache()) {
//不需要緩存的話直接加入隊列拔创，使用的是PriorityBlockingQueue---一個基于優(yōu)先級堆的無界的并發(fā)安全的優(yōu)先級隊列
mNetworkQueue.add(request);
return request;
}
// Insert request into stage if there's already a request with the same cache key in flight.
//mWaitingRequest 對應(yīng)一個map<key,queue<request>>
synchronized (mWaitingRequests) {
//key對應(yīng)著url
String cacheKey = request.getCacheKey();
if (mWaitingRequests.containsKey(cacheKey)) {
//如果已經(jīng)有一個相同的請求已經(jīng)在等待隊列里，則將現(xiàn)在這個請求放入相同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的信息富蓄，當(dāng)為null表明這個key對應(yīng)的請求就這一個剩燥，由于需要緩存，則加入緩存隊列
mWaitingRequests.put(cacheKey, null);
mCacheQueue.add(request);
}
return request;
}
}
第一步：首先將request加入mCurrentRequests立倍。這里注意：
mCurrentRequests是一個HashSet,HashSet底層是一個HashMap,所以不是線程安全的灭红，這里為了線程安全，利用synchronized關(guān)鍵字實現(xiàn)了加鎖操作口注。
第二步：給request添加了序列號变擒。
這里用到了AtomicInteger，是一個線程安全的Integer疆导，適用于高并發(fā)的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默認(rèn)都是需要緩存的，如果不需要败富，則需要顯式的調(diào)研request的setShouldCache方法悔醋。這里如果不需要緩存，則直接將request加入網(wǎng)絡(luò)請求隊列（如下代碼所示）兽叮。這里使用的是PriorityBlockingQueue---一個基于優(yōu)先級堆的無界的并發(fā)安全的優(yōu)先級隊列芬骄。
if (!request.shouldCache()) {
//不需要緩存的話直接加入隊列猾愿，使用的是PriorityBlockingQueue---一個基于優(yōu)先級堆的無界的并發(fā)安全的優(yōu)先級隊列
mNetworkQueue.add(request);
return request;
}
第四步：如果需要緩存，這里對應(yīng)需要插入到兩個地方mWaitingRequests和mCacheQueue账阻，這里由于mWaitingRequests是一個HashMap蒂秘，所以同樣，需要通過synchronized關(guān)鍵字進行加鎖操作淘太。這里分細(xì)一點看：
String cacheKey = request.getCacheKey();
if (mWaitingRequests.containsKey(cacheKey)) {
//如果已經(jīng)有一個相同的請求已經(jīng)在等待隊列里姻僧，則將現(xiàn)在這個請求放入相同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對應(yīng)的數(shù)據(jù)結(jié)構(gòu)是map<key,queue<request>>，key對應(yīng)的是url蒲牧。首先判斷mWaitingRequest中是否存在相同的url的request撇贺，如果存在，則取出存放這種url的requestqueue冰抢，存在這個url松嘶，但對應(yīng)的queue為空，則new一個挎扰，并且將這個request加入queue,并將queue加入mWatingRequest翠订。
else {
// Insert 'null' queue for this cacheKey, indicating there is now a request in
// flight.
//沒有的話則插入一個key-null的信息，當(dāng)為null表明這個key對應(yīng)的請求就這一個鼓鲁，由于需要緩存蕴轨，則加入緩存隊列
mWaitingRequests.put(cacheKey, null);
mCacheQueue.add(request);
}
2）如果不存在，則插入一個key-null到mWaitingRequest中骇吭，并將這個請求加入mCacheQueue緩存隊列橙弱。
所以這里一個需要緩存的request進入情況就很好分析了，一個新的request加入進來燥狰，對應(yīng)的棘脐，mWaitingRequest存放一個key-null。當(dāng)同樣的一個url的request進入的時候龙致，就會放到mWaitingRequest中等待蛀缝，而這時候mWaitingRequest存在該url的隊列，只不過queue為null目代，這時候就會new一個新的queue放入mWaitingRequest,等下次有同樣的url進入的時候屈梁，就會直接加入這個隊列中等待。
