- 通过Volley.newReuqestQueue新建一个请求队列（VolleyQueue），在创建请求队列之后，会调用start()方法，在后台开启5个线程，一个是缓存线程，4个网络请求的线程。start()方法如下：
public void start() {
mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
mCacheDispatcher.start();//启动缓存线程 父类是Thread
// Create network dispatchers (and corresponding threads) up to the pool size.
for (int i = 0; i < mDispatchers.length; i++) {
NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
mCache, mDelivery);
mDispatchers[i] = networkDispatcher;
networkDispatcher.start();//启动网络线程 父类是Thread
}
}
上面的mCacheQueue，mNetworkQueue都是阻塞队列，作用在下文可以体现。
当我们往队列中加入request的时候，会检查request是否可以被缓存，默认情况下是可以的，如果用户设置了不可以被缓存，那么会直接将request加入到网络请求的队列当中（mNetworkQueue）。
如果可以被缓存，且如果没有相同的request正在请求，那么会将request加入到缓存队列，并在一个Hashmap中加入该Request的key，value为null。如果在Request请求的过程中，有相同的Request到来，那么会将这些新的Request通过链表连接，放入到Hashmap的value中。等待正在请求的Request完成之后，会将这些相同的Request全部取出，加入到缓存队列。
add()方法代码如下：
public Request add(Request request) {
request.setRequestQueue(this);//保存VolleyQueue对象 request完成之后会进行回调
synchronized (mCurrentRequests) {
mCurrentRequests.add(request);//加入到正在请求的Request集合
}
if (!request.shouldCache()) {
mNetworkQueue.add(request);//request不支持缓存 直接添加到网络请求队列
return request;
}
// 支持缓存
synchronized (mWaitingRequests) {
String cacheKey = request.getCacheKey();
//mWaitingRequests就是上面提到的那个Hashmap
if (mWaitingRequests.containsKey(cacheKey)) {//含有key 说明有正在请求的Request
Queue> stagedRequests = mWaitingRequests.get(cacheKey);
if (stagedRequests == null) {
stagedRequests = new LinkedList>();
}
stagedRequests.add(request);//之后key相同的Request用链表串起来
mWaitingRequests.put(cacheKey, stagedRequests);
} else {
mWaitingRequests.put(cacheKey, null);//第一次value为null
mCacheQueue.add(request);//新的request添加到缓存队列
}
return request;
}
}
- 缓存线程会不断从缓存队列中取出request，并查看是否已经有了缓存，如果有缓存并且缓存还没有过期，则会将response分发到主线程中进行回调，采用的是handler机制发送到主线程
缓存线程（CacheDispatcher）的run方法：
public void run() {
mCache.initialize();//初始化缓存
Request request;
while (true) {
request = null;
try {
// 从缓存队列取request 如果没有request 会阻塞
//典型的生产者 消费者模型
request = mCacheQueue.take();
} catch (InterruptedException e) {
if (mQuit) {
return;
}
continue;
}
try {
// If the request has been canceled, don't bother dispatching it.
if (request.isCanceled()) {
request.finish("cache-discard-canceled");//完成request
continue;
}
// Attempt to retrieve this item from cache.
Cache.Entry entry = mCache.get(request.getCacheKey());
if (entry == null) {
request.addMarker("cache-miss");
//没有缓存 添加到网络请求队列
mNetworkQueue.put(request);
continue;
}
//缓存过期了 添加到网络请求队列
if (entry.isExpired()) {
request.addMarker("cache-hit-expired");
request.setCacheEntry(entry);
mNetworkQueue.put(request);
continue;
}
// 能到达这步说明 缓存可用
Response response = request.parseNetworkResponse(
new NetworkResponse(entry.data, entry.responseHeaders));
if (!entry.refreshNeeded()) {
// 缓存不需要更新 直接分派缓存的response就好
mDelivery.postResponse(request, response);
} else {
request.setCacheEntry(entry);
response.intermediate = true;
// 缓存需要刷新 将结果分派给用户 并重新添加到网络请求队列
final Request finalRequest = request;
mDelivery.postResponse(request, response, new Runnable() {
@Override
public void run() {
try {
mNetworkQueue.put(finalRequest);//重新添加到网络请求队列
} catch (InterruptedException e) {
// Not much we can do about this.
}
}
});
}
} catch (Exception e) {
VolleyLog.e(e, "Unhandled exception %s", e.toString());
}
}
}
- 如果缓存过期了，那么会将request加入到网络请求队列之中。网络请求线程会从网络请求队列中取出request，进行网络请求，请求完成之后会将结果进行缓存，并将结果传回主线程
public void run() {
Request request;
while (true) {
request = null;
try {
// 从请求队列里面取request
request = mQueue.take();
} catch (InterruptedException e) {
if (mQuit) {
return;
}
continue;
}
try {
if (request.isCanceled()) {
request.finish("network-discard-cancelled");//完成request
continue;
}
// Perform the network request.
NetworkResponse networkResponse = mNetwork.performRequest(request);
if (networkResponse.notModified && request.hasHadResponseDelivered()) {
request.finish("not-modified");
continue;
}
// 解析Response
Response response = request.parseNetworkResponse(networkResponse);
request.addMarker("network-parse-complete");
// 如果可以 将缓存保存起来.
if (request.shouldCache() && response.cacheEntry != null) {
mCache.put(request.getCacheKey(), response.cacheEntry);
}
request.markDelivered();
mDelivery.postResponse(request, response);//分派结果
} catch (VolleyError volleyError) {
volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
parseAndDeliverNetworkError(request, volleyError);
} catch (Exception e) {
VolleyLog.e(e, "Unhandled exception %s", e.toString());
VolleyError volleyError = new VolleyError(e);
volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
mDelivery.postError(request, volleyError);
}
}
}
6.request完成的时候将保存在hashmap中的具有相同key的request取出来，全部加入到缓存队列，由于刚刚才完成对request的请求，所以缓存一般都是有效的，所以会直接把response分发给各个request对应的回调函数。
Request的finish方法：
void finish(final String tag) {
if (mRequestQueue != null) {
mRequestQueue.finish(this);//VolleyQueue的finish方法
onFinish();
}
······
}
VolleyQueue的finish方法：
void finish(Request request) {
// Remove from the set of requests currently being processed.
synchronized (mCurrentRequests) {
mCurrentRequests.remove(request);//从正在请求的集合移出已完成的request对象
}
synchronized (mFinishedListeners) {
for (RequestFinishedListener listener : mFinishedListeners) {
listener.onRequestFinished(request);
}
}
if (request.shouldCache()) {//request能够被缓存才需要进行下面的判断
synchronized (mWaitingRequests) {
String cacheKey = request.getCacheKey();
Queue> waitingRequests = mWaitingRequests.remove(cacheKey);
if (waitingRequests != null) {
//将具有相同key的request添加到缓存队列
mCacheQueue.addAll(waitingRequests);
}
}
}
}
- 缓存是存在本地的，默认缓存大小是5M，如果缓存满了，会通过FIFO算法，将老的缓存进行删除。