Volley 核心源码解析（三）
Volley 的任务调度模型
接着上一节的 RequestQueue,在Volley 初始化 RequestQueue的时候 会执行 RequestQueue 的 start()方法，在start方法中 初始化了，缓存调度器和网络调度器。
public void start() {
stop(); // Make sure any currently running dispatchers are stopped.
// Create the cache dispatcher and start it.
mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
mCacheDispatcher.start();
// 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();
}
}
看看NetworkDispatcher 和 CacheDispatcher 是什么东东？
NetworkDispatcher extends Thread
CacheDispatcher extends Thread
结果两个都是线程类。
再看看循环体中 往一个叫做mDispatchers[i] 的数组中赋值了若干 NetworkDispatcher，且每个NetworkDispatcher都在创建的时候 就启动了。
找到 mDispatchers的定义：
private static final int DEFAULT_NETWORK_THREAD_POOL_SIZE = 4;
mDispatchers = new NetworkDispatcher[threadPoolSize];
原来是个默认4个元素的 线程组。
看到这里我似乎想到了线程池的基本概念，没错 这就是个线程池。
看看具体的 NetworkDispatcher 是什么样的？
做过JAVA 开发的都知道 继承 thread 类一定要重写 run（）方法
在NetworkDispatcher中run 方法如下：
方法太长 一段一段的来看哈
因为是要做线程池嘛，所以线程要一直工作，所以一进run方法 就是 while(true){}
了，
Request request = mQueue.take();
mQueue：mNetworkQueue
在 PriorityBlockingQueue 队列中 take 方法如下：
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
E result;
try {
while ( (result = dequeue()) == null)
notEmpty.await();
} finally {
lock.unlock();
}
return result;
}
意思就是加锁 -->取出一个请求->释放锁->原队列中请求减少一个
这样就保证了 使用 volley 发送请求的时候 能按照发送请求的顺序去执行。
接下来 从队列中取出请求之后，给请求设置备注，判断请求时否被取消，如果被取消就finish。
request.addMarker("network-queue-take");
// If the request was cancelled already, do not perform the
// network request.
if (request.isCanceled()) {
request.finish("network-discard-cancelled");
continue;
}
紧接着，执行该请求：
// Perform the network request.
NetworkResponse networkResponse = mNetwork.performRequest(request);
后面就是对 networkResponse 的一些状态判断和解析。
Response response = request.parseNetworkResponse(networkResponse);
在volley 中 解析NetworkResponse 的具体方法 交给 Request 的 子类去实现。如，ImageRequest,JsonRequest,StringRequest等
同时,缓存 这个已经执行的请求：
if (request.shouldCache() && response.cacheEntry != null) {
mCache.put(request.getCacheKey(), response.cacheEntry);
request.addMarker("network-cache-written");
}
看到这里，我们可以得出一个结论，Volley 初始化 RequestQueue 的时候 创建了一个
默认4个大小的线程池，每个线程同步 的从PriorityBlockingQueue 类型的请求队列中拿出一个请求并执行。
接下来看看 CacheDispatcher 缓存任务调度：
/** The queue of requests coming in for triage. */
private final BlockingQueue> mCacheQueue;
/** The queue of requests going out to the network. */
private final BlockingQueue> mNetworkQueue;
与 NetworkDispatcher 不同的是 CacheDispatcher 不仅有缓存队列 还有请求队列，
同样是while (true) { request = mCacheQueue.take();; ...}
不停的从 mCacheQueue 拿出缓存过的请求：
// Attempt to retrieve this item from cache.
Cache.Entry entry = mCache.get(request.getCacheKey());
if (entry == null) {
request.addMarker("cache-miss");
// Cache miss; send off to the network dispatcher.
mNetworkQueue.put(request);
continue;
}
这里看到 被缓存的请求时根据请求的cacheKey 从cache中取出，如果取出的缓存为空，直接把请求 放到 mNetworkQueue ，也就是说把请求交给 了 NetworkDispatcher去执行。
如果请求的缓存对象过期,同上:
// If it is completely expired, just send it to the network.
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));
这是什么意思呢？
Volley不仅缓存了请求本身，而且缓存了请求的响应结果，此时做的就是从缓存中取出响应的结果，这样就不用再发请求去服务器上了。
接下来，
if (!entry.refreshNeeded()) {
// Completely unexpired cache hit. Just deliver the response.
mDelivery.postResponse(request, response);
} else {
// Soft-expired cache hit. We can deliver the cached response,
// but we need to also send the request to the network for
// refreshing.
request.addMarker("cache-hit-refresh-needed");
request.setCacheEntry(entry);
// Mark the response as intermediate.
response.intermediate = true;
// Post the intermediate response back to the user and have
// the delivery then forward the request along to the network.
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.
}
}
});
}
如果缓存数据不需要刷新，只需要用回掉接口返回值，反之，把请求放入mNetworkQueue，等待 NetworkDispatcher 执行。
至此，Volley 的 线程模型分析告一段落，我们看到了线程组 NetworkDispatcher[] 和 单线程 CacheDispatcher 通过 两个 BlockingQueue 巧妙地实现了网络请求任务的交替轮换。
