Volley的分析大致可以分为五部分：
1、执行流程
2、网络请求流程
3、缓存流程
4、数据解析
5、数据分发
6、图片加载
下面分析一下Volley的执行流程，从整天上了解框架可以免于过度纠结某些细节，有一个宏观的认识，有助于源码阅读。
Volley的使用很简单，获取一个RequestQueue：
RequestQueue mQueue = Volley.newRequestQueue(context);
再创建一个Request请求，只要mQueue.add(request)就可以自动执行请求返回数据了。
Volley.class
Volley类提供了四个静态newRequestQueue方法：
＊public static RequestQueue newRequestQueue(Context context, BaseHttpStack stack)
＊public static RequestQueue newRequestQueue(Context context, HttpStack stack)
＊private static RequestQueue newRequestQueue(Context context, Network network)
＊public static RequestQueue newRequestQueue(Context context)
其中三个publish公开方法最终都是调用了private方法：
这个涉及到了三个类：RequestQueue、DiskBasedCache和Network和一个RequestQueue.start()方法。
不要着急，这里主要看RequestQueue构造。
RequestQueue.class
其中有两个重要的final变量
PriorityBlockingQueue<Request<?>> mCacheQueue = new PriorityBlockingQueue<>();
PriorityBlockingQueue<Request<?>> mNetworkQueue = new PriorityBlockingQueue<>();
分别是缓存队列和网络请求队列，但我们要特别注意的是他们的类型：PriorityBlockingQueue。
这是一个优先级阻塞队列类型，注意：理解BlockingQueue对于Volley有至关重要的作用！！！
通过线程中while(true)和BlockingQueue的组合，可以实现类似监听数据源的效果。
RequestQueue.add(Request)方法：
public <T> Request<T> add(Request<T> request) {
//先判断请求是否需要缓存数据，如果不需要缓存就加入mNetworkQueue网络请求队列中。
if (!request.shouldCache()) {
mNetworkQueue.add(request);
return request;
}
//如果需要缓存数据，则将请求对象加入到mCacheQueue缓存请求队列中。
mCacheQueue.add(request);
return request;
}
如果不需要缓存，直接放入网络队列中让Volley进行网络请求，需要缓存放入缓存队列，这很好理解，但是单单放入缓存队列如何进行网络请求呢？接着往下看RequestQueue的start方法：
start方法中构建了一个CacheDispatcher缓存调度器线程(CacheDispatcher继承了Thread类)并传入了mCacheQueue缓存请求队列和mNetworkQueue网络请求队列，然后调用了调度器线程的start方法启动线程。那么就要看CacheDispatcher的run方法了，下面来详细分析一下run方法：
/**
* 关键点：
* 如果，request有缓存并且未过期就直接分发出去response；
* 否则，看request是否已经有了等待结果的前辈，有就加入进去；
* 最后的情况，只能放到networkQueue中等待执行网络请求了。
*/
public void run() {
// 初始化缓存类Cache
mCache.initialize();
//重点：while(true)无限循环，配合BlockingQueue就能实现一个类似监听器功能。监听到队列中有值就会执行。
while (true) {
try {
//cacheQueue是BlockingQueue阻塞队列，也就是说get取不到值就会阻塞直到有值才会执行。
final Request<?> request = mCacheQueue.take();
request.addMarker("cache-queue-take");
// 如果请求已经被取消，跳过本次请求过程。
if (request.isCanceled()) {
request.finish("cache-discard-canceled");
continue;
}
// 根据请求从volley的缓存管理类中获取对应的缓存实体。
Cache.Entry entry = mCache.get(request.getCacheKey());
if (entry == null) {
request.addMarker("cache-miss");
// 如果请求没有缓存，就把请求放入到网络请求队列中并结束本次流程。注意：这就解释了前面start方法中为什么单单把请求放入缓存队列中就可以就行缓存和网络请求动作，因为当没有缓存数据时就放入网络请求队列中，而mNetworkQueue也是网络调用器的数据源，自然就可以执行网络请求动作了。
if (!mWaitingRequestManager.maybeAddToWaitingRequests(request)) {
//maybeAddToWaitingRequests是用于判断是否有与这个request请求相同的请求在等待这结果，如果有就一起存起来，等返回结果来的时候同时赋值返回，这样可以有效的避免相同的网络请求浪费资源。
mNetworkQueue.put(request);
}
continue;
}
//下面就全都是有缓存的情况了
//如果缓存数据已超时失效，也放入网络请求队列中重新请求数据并结束。
if (entry.isExpired()) {
request.addMarker("cache-hit-expired");
request.setCacheEntry(entry);
if (!mWaitingRequestManager.maybeAddToWaitingRequests(request)) {
mNetworkQueue.put(request);
}
continue;
}
// 如果缓存没有过期就将缓存数据解析成返回对象Response。
request.addMarker("cache-hit");
Response<?> response = request.parseNetworkResponse(
new NetworkResponse(entry.data, entry.responseHeaders));
request.addMarker("cache-hit-parsed");
//refreshNeeded的意思是请求的数据使用缓存数据，数据能够快速返回。那之后是否还想默默的用网络数据刷新一下这个请求的缓存数据呢
if (!entry.refreshNeeded()) {
// 缓存数据完成解析并且不需要刷新，则通过mDelivery分发器将结果直接分发出去。
mDelivery.postResponse(request, response);
} else {
if (!mWaitingRequestManager.maybeAddToWaitingRequests(request)) {
// 如果获取缓存后还想刷新数据，那就再返回缓存数据后将请求再放入到网络请求列表中执行网络请求获取网络最新数据。
mDelivery.postResponse(request, response, new Runnable() {
@Override
public void run() {
try {
mNetworkQueue.put(request);
} catch (InterruptedException e) {
// Restore the interrupted status
Thread.currentThread().interrupt();
}
}
});
} else {
// request has been added to list of waiting requests
// to receive the network response from the first request once it returns.
mDelivery.postResponse(request, response);
}
}
} catch (InterruptedException e) {
// We may have been interrupted because it was time to quit.
if (mQuit) {
return;
}
}
}
}
总结以下，缓存调度器CacheDispatcher的原理是通过while(true)无限循环与BlockingQueue阻塞队列配合，当缓存阻塞队列中有值就能get出来执行，阻塞队列空的时候线程就一直等待。对于请求就先看volley中是否有缓存，如果有就解析成Response直接返回，没有就将请求再放入到网络请求列表中。是一个责任链模型。
接下来再来看网络请求调度器类NetworkDispatcher.class，这个分析就简单多了，因为它与CacheDispatcher结构基本是相同的：
/**
* 在RequestQueue中有多个NetworkDispatcher同时运行，但他们都是使用同一个BlockQueue作为数据源。这样就可以用一个数据源控制多个并发线程了。
*
* 网络线程的一个执行流程大概要经过以下几步：
* 1、执行网络请求。
* 2、解析网络返回结果。
* 3、缓存解析后的结果。
* 4、分发结果。
*/
@Override
public void run() {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
while (true) {
long startTimeMs = SystemClock.elapsedRealtime();
Request<?> request;
try {
// 由网络请求队列BlockingQueue中获取数据。
request = mQueue.take();
} catch (InterruptedException e) {
if (mQuit) {
return;
}
continue;
}
try {
request.addMarker("network-queue-take");
if (request.isCanceled()) {
request.finish("network-discard-cancelled");
request.notifyListenerResponseNotUsable();
continue;
}
addTrafficStatsTag(request);
//最终行为：执行网络操作，代码转入Network中
NetworkResponse networkResponse = mNetwork.performRequest(request);
request.addMarker("network-http-complete");
//如果服务器返回304(数据未改变)，或者这个返回结果已经分发过了，那就不用再次分发了。
if (networkResponse.notModified && request.hasHadResponseDelivered()) {
request.finish("not-modified");
request.notifyListenerResponseNotUsable();
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.addMarker("network-cache-written");
}
//分发结果
request.markDelivered();
mDelivery.postResponse(request, response);
request.notifyListenerResponseReceived(response);
} catch (VolleyError volleyError) {
volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
parseAndDeliverNetworkError(request, volleyError);
request.notifyListenerResponseNotUsable();
} 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);
request.notifyListenerResponseNotUsable();
}
}
}
最后整理下流程：Volley通过创建一个RequestQueue从而间接创建了CacheDispatcher和NetworkDispatcher对象，CacheDispatcher同时持有CacheQueue队列和NetworkQueue队列。通过RequestQueue的add方法可以将请求Request加入到CacheQueue中，CacheDispatcher从CacheQueue中取到值并判断volley中是否有缓存数据，有就返回缓存，没有就将Request继续放到NetworkQueue中，由于NetworkQueue持有的是同一个NetworkQueue引用，所以NetworkQueue会负责这个request的网络请求。
