从RequestQueue开始：
- 创建一个RequestQueue：
mRequestQueue = Volley.newRequestQueue(getApplicationContext());
一般一个程序只需要一个请求队列，所以在Application中初始化RequestQueue是不错的用法。
newRequestQueue点进去可以看到，其实Volly类中主要封装了创建RequestQueue的几个重载方法，输入不同的参数可以配置不同RequestQueue。
public static RequestQueue newRequestQueue(Context context, HttpStack stack, int maxDiskCacheBytes) {
File cacheDir = new File(context.getCacheDir(), "volley");
String userAgent = "volley/0";
try {
String packageName = context.getPackageName();
PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
userAgent = packageName + "/" + info.versionCode;
} catch (NameNotFoundException var7) {
;
}
if(stack == null) {
if(VERSION.SDK_INT >= 9) {
stack = new HurlStack();
} else {
stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}
Network network = new BasicNetwork((HttpStack)stack);
RequestQueue queue;
if(maxDiskCacheBytes <= -1) {
queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
} else {
queue = new RequestQueue(new DiskBasedCache(cacheDir, maxDiskCacheBytes), network);
}
queue.start();
return queue;
}
这个方法里，首先配置一些缓存文件的信息和包的信息等。然后根据传入的参数stack，判断是否为NULL。在为NULL的情况下，根据当前SDK的版本，选择使用HttpURLConnection或者HttpClient作为底层的网络请求框架。（关于HttpURLConnection和HttpURLConnection的内容后面再进行介绍。
接着，通过stack创建Network接口的BasicNetwork对象，而该对象封装了进行http请求的一系列配置等。
最后，通过创建所得的Network对象和缓冲大小创建一个RequestQueue对象并返回。（注意queue.start()方法）。
- RequestQueue的成员变量
上面我们创建RequestQueue对象，那么这个RequestQueue对象的用处是？从字面上来将，它的意思是请求队列，事实上它的确维护着多个队列。点击去看一下：
它成员变量有：
private AtomicInteger mSequenceGenerator;
private final Map<String, Queue<Request<?>>> mWaitingRequests;
private final Set<Request<?>> mCurrentRequests;
private final PriorityBlockingQueue<Request<?>> mCacheQueue;
private final PriorityBlockingQueue<Request<?>> mNetworkQueue;
private static final int DEFAULT_NETWORK_THREAD_POOL_SIZE = 4;
private final Cache mCache;
private final Network mNetwork;
private final ResponseDelivery mDelivery;
private NetworkDispatcher[] mDispatchers;
private CacheDispatcher mCacheDispatcher;
private List<RequestQueue.RequestFinishedListener> mFinishedListeners;
mSequenceGenerator：用于生成请求的单调递增序列号。使用AtomicInteger的原因是一种无锁的线程安全整数，减少了并发的消耗（不需要使用关键字synchronized）。
mWaitingRequests：重复缓存请求的暂存队列。
mCurrentRequests：也就是所有被执行中的或者等待中的请求对象。注意到它是一个set，即不允许有重复对象。
mCacheQueue：若创建request的时候允许被缓存，则会被放到该队列中，若不允许被缓存，则会被放到mNetworkQueue队列中。
mNetworkQueue：同上。
DEFAULT_NETWORK_THREAD_POOL_SIZE ：默认网络线程数目。
Cache：缓存接口，可以实现该接口配置不同的缓存策略。
Network：上面提到的网络请求框架接口。也可以自己配置。
mDelivery：响应机制的接口，配置有关响应成功或者失败的操作信息。
mDispatchers：网络请求线程的数组，通过mNetworkQueue.take()方法取出响应的网络请求。
mCacheDispatcher：同上，只不过它是一条线程而不是一个数组。
mFinishedListeners：请求完成的响应队列。
- RequestQueue的构造函数
接下来看到RequestQueue的构造函数：
public RequestQueue(Cache cache, Network network, int threadPoolSize, ResponseDelivery delivery) {
this.mSequenceGenerator = new AtomicInteger();
this.mWaitingRequests = new HashMap();
this.mCurrentRequests = new HashSet();
this.mCacheQueue = new PriorityBlockingQueue();
this.mNetworkQueue = new PriorityBlockingQueue();
this.mFinishedListeners = new ArrayList();
this.mCache = cache;
this.mNetwork = network;
this.mDispatchers = new NetworkDispatcher[threadPoolSize];
this.mDelivery = delivery;
}
基本上就是对其成员变量的初始化。
- start()方法
继续往下看可以看到一个start()方法：
public void start() {
this.stop();
this.mCacheDispatcher = new CacheDispatcher(this.mCacheQueue, this.mNetworkQueue, this.mCache, this.mDelivery);
this.mCacheDispatcher.start();
for(int i = 0; i < this.mDispatchers.length; ++i) {
NetworkDispatcher networkDispatcher = new NetworkDispatcher(this.mNetworkQueue, this.mNetwork, this.mCache, this.mDelivery);
this.mDispatchers[i] = networkDispatcher;
networkDispatcher.start();
}
}
从表面上看，start()方法其实就是将执行缓存任务的线程和执行网络任务的线程start()了。所以以CacheDispatcher为例，分析其任务执行线程做了什么工作。
public void run() {
if(DEBUG) {
VolleyLog.v("start new dispatcher", new Object[0]);
}
Process.setThreadPriority(10);
this.mCache.initialize();
while(true) {
while(true) {
while(true) {
while(true) {
try {
while(true) {
final Request<?> request = (Request)this.mCacheQueue.take();
request.addMarker("cache-queue-take");
if(request.isCanceled()) {
request.finish("cache-discard-canceled");
} else {
Entry entry = this.mCache.get(request.getCacheKey());
if(entry == null) {
request.addMarker("cache-miss");
this.mNetworkQueue.put(request);
} else if(entry.isExpired()) {
request.addMarker("cache-hit-expired");
request.setCacheEntry(entry);
this.mNetworkQueue.put(request);
} else {
request.addMarker("cache-hit");
Response<?> response = request.parseNetworkResponse(new NetworkResponse(entry.data, entry.responseHeaders));
request.addMarker("cache-hit-parsed");
if(entry.refreshNeeded()) {
request.addMarker("cache-hit-refresh-needed");
request.setCacheEntry(entry);
response.intermediate = true;
this.mDelivery.postResponse(request, response, new Runnable() {
public void run() {
try {
CacheDispatcher.this.mNetworkQueue.put(request);
} catch (InterruptedException var2) {
;
}
}
});
} else {
this.mDelivery.postResponse(request, response);
}
}
}
}
} catch (InterruptedException var4) {
if(this.mQuit) {
return;
}
}
}
}
}
}
}
可以看到，该线程的RUN方法中有多死个循环，先看最里层的。
首先调用mCacheQueue.take()方法取出请求对象，而这个mCacheQueue之前提过，是一个BlockingQueue，即阻塞队列。其take()方法为从队列中取得对象，如果队列不存在对象，将会被阻塞，直到队列中存在有对象。这就使得在节约系统资源的情况下，RequestQueue只需要start一次就够了。
接着设置DEBUG的一些信息和检查该请求是否被取消。并且，由于这个是缓存任务的执行线程，将会在缓存信息中查找之前是否有缓存该任务的信息，如果有，缓存命中，判断是否过期。所以未命中的和缓存过期的都会被放到mNetworkQueue中执行，否则，直接从缓存实体对象entry中取出数据进行解析并分发。同时，如果是软命中缓存的话，虽然提供缓存数据的响应，但仍需要加入mNetworkQueue中重写执行请求以刷新内容。
分析下来，其实这里并不需要多层死循环，并且我在其他版本的volley源码中也有只有一层的循环的情况，所以这里的用意我不大明确。
- cancelAll()方法
回到RequestQueue中，先看个简单cancelAll方法：
public void cancelAll(RequestQueue.RequestFilter filter) {
Set var2 = this.mCurrentRequests;
synchronized(this.mCurrentRequests) {
Iterator var4 = this.mCurrentRequests.iterator();
while(var4.hasNext()) {
Request<?> request = (Request)var4.next();
if(filter.apply(request)) {
request.cancel();
}
}
}
}
取消过滤出来的请求，其另一个重载方法则是直接将filter设置为tag是否一致。（在python中则是直接一个lambda搞定）。
- add()方法
其实在我们使用volley的时候，通过在创建出Request之后，将它添加进RequestQueue中就完事，并不需要手动去开启请求，那么Volley是如何做到的呢。
public <T> Request<T> add(Request<T> request) {
request.setRequestQueue(this);
Set var2 = this.mCurrentRequests;
synchronized(this.mCurrentRequests) {
this.mCurrentRequests.add(request);
}
request.setSequence(this.getSequenceNumber());
request.addMarker("add-to-queue");
if(!request.shouldCache()) {
this.mNetworkQueue.add(request);
return request;
} else {
Map var7 = this.mWaitingRequests;
synchronized(this.mWaitingRequests) {
String cacheKey = request.getCacheKey();
if(this.mWaitingRequests.containsKey(cacheKey)) {
Queue<Request<?>> stagedRequests = (Queue)this.mWaitingRequests.get(cacheKey);
if(stagedRequests == null) {
stagedRequests = new LinkedList();
}
((Queue)stagedRequests).add(request);
this.mWaitingRequests.put(cacheKey, stagedRequests);
if(VolleyLog.DEBUG) {
VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", new Object[]{cacheKey});
}
} else {
this.mWaitingRequests.put(cacheKey, (Object)null);
this.mCacheQueue.add(request);
}
return request;
}
}
}
可以看到，每个请求首先会被加入，mCurrentRequests队列中，正如我们前面所说的，mCurrentRequests是所以被执行或者等待中的请求的集合。接着，根据请求是否需要缓存，分别被加入了mNetworkQueue和mCacheQueue，而mWaitingRequests中则维护了具有相同的cacheKey中所有请求的队列。
到这里仍没有解释为什么VOLLEY不需要手动去开启请求。但是其实，上面有讲到mCacheQueue和mNetworkQueue是一个BlockingQueue，在响应的执行线程中通过调用take()方法取得任务或者阻塞线程，我们把请求放进去的时候后，若请求执行线程有空的时候，请求就会被取出并执行。
- finish()方法
当请求完成后，我们需要从中取得回调数据，finish()方法就是处理这一块的函数。
<T> void finish(Request<T> request) {
Set var2 = this.mCurrentRequests;
synchronized(this.mCurrentRequests) {
this.mCurrentRequests.remove(request);
}
List var8 = this.mFinishedListeners;
synchronized(this.mFinishedListeners) {
Iterator var4 = this.mFinishedListeners.iterator();
while(true) {
if(!var4.hasNext()) {
break;
}
RequestQueue.RequestFinishedListener<T> listener = (RequestQueue.RequestFinishedListener)var4.next();
listener.onRequestFinished(request);
}
}
if(request.shouldCache()) {
Map var9 = this.mWaitingRequests;
synchronized(this.mWaitingRequests) {
String cacheKey = request.getCacheKey();
Queue<Request<?>> waitingRequests = (Queue)this.mWaitingRequests.remove(cacheKey);
if(waitingRequests != null) {
if(VolleyLog.DEBUG) {
VolleyLog.v("Releasing %d waiting requests for cacheKey=%s.", new Object[]{Integer.valueOf(waitingRequests.size()), cacheKey});
}
this.mCacheQueue.addAll(waitingRequests);
}
}
}
}
首先，完成的请求将会被从mCurrentRequests移除，遍历请求队列中所有的完成回调接口，并执行每个listener的回调方法。最后，如果请求可以缓存，在将其从mWaitingRequests中移除，并且将与该请求具有相同cacheKey的请求移入mCacheQueue中处理。以提高处理效率。
小结
到这里，RequestQueue就基本讲完了，对其也有了个大概的了解。下一篇文章计划解析Request类。
