[置顶] Volley源码阅读(0)

在RequestQueue类中

1、首先看add方法

if (!request.shouldCache()) {
mNetworkQueue.add(request);
return request;
}

在他的add方法中会判断是否需要缓存.shouldCache(),需要则添加到mNetworkQueue网络处理队列，至此返回

否则进入缓存队列处理

synchronized (mWaitingRequests) {
String cacheKey = request.getCacheKey();
if (mWaitingRequests.containsKey(cacheKey)) {
// There is already a request in flight. Queue up.
Queue<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);
if (stagedRequests == null) {
stagedRequests = new LinkedList<Request<?>>();
}
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.
mWaitingRequests.put(cacheKey, null);
mCacheQueue.add(request);
}
return request;
}

在加入缓存队列前每个请求得到都会判断该请求是否正在执行（flight）判断条件就是请求的cacheKey是否对应 map集合mWaitingRequests

2、再来看finish方法（因为上面的mWaitingRequest在finish方法中被处理了）

```
<T> void finish(Request<T> request) {
// Remove from the set of requests currently being processed.
synchronized (mCurrentRequests) {
mCurrentRequests.remove(request);
}
synchronized (mFinishedListeners) {
for (RequestFinishedListener<T> listener : mFinishedListeners) {
listener.onRequestFinished(request);
}
}

if (request.shouldCache()) {
synchronized (mWaitingRequests) {
String cacheKey = request.getCacheKey();
Queue<Request<?>> waitingRequests = mWaitingRequests.remove(cacheKey);
if (waitingRequests != null) {
if (VolleyLog.DEBUG) {
VolleyLog.v("Releasing %d waiting requests for cacheKey=%s.",
waitingRequests.size(), cacheKey);
}
// Process all queued up requests. They won't be considered as in flight, but
// that's not a problem as the cache has been primed by 'request'.
mCacheQueue.addAll(waitingRequests);
}
}
}
```

上面代码中做了这些事：

将请求从mCurrentRequests主队列（存了网络队列和缓存队列）移除了，添加了请求完成监听，如果该请求同时是能被缓存的则把存于mWaitingRequests中的相同请求取出并加入mCacheQueue缓存队列。（个人认为这是为了处理多次相同请求能够依次进行缓存，而HashMap不支持相同键值对存在，所以引入mWaitingRequests）

推测引入mWaitingRequest是为了处理相同请求多次依次处理而作为中间存储空间。

从注释中可以看到

* Called from {@link Request#finish(String)}, indicating that processing of the given request

* has finished.

finish是在Request中的finish被调用的

那么Request中怎么有RequestQueue对象呢？因为Request中有setRequestQueue，在RequestQueue中的add方法一开始就调用了

也就是说每一个被添加到RequestQueue中Request都与RequestQueue绑定了。

3、看start方法

```
/**
* Starts the dispatchers in this queue.
*/
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();
}
}
```

先调用了stop方法，将当前的正在运行的dispatchers全部停掉

再创建了缓存分发线程和网络分发线程

CacheDispatcher（）中的参数：mCacheQueue–>缓存请求队列 |

mNetworkQueue–>网络请求队列 |-都是实现Queue接口的PriorityBlockingQueue对象，指针

mCache–>缓存操作对象，默认传入的是DiskBasedCache对象（这里用于读取缓存）

mDelivery–>监听接口传递，是实现了ResponseDelivery的子类ExecutorDelivery的对象

|-它的方法postResponse可以用于绑定Response响应结果给监听器

NetworkDispatcher()中的参数：mNetworkQueue–>网络请求队列

mNetwork–>网络请求对象，能够执行网络请求

mCache–>缓存操作对象，默认传入的是DiskBasedCache对象（这里用于写入缓存）

mDelivery–>监听接口传递，是实现了ResponseDelivery的子类ExecutorDelivery的对象

|-它的方法postResponse可以用于绑定Response响应结果给监听器

4、看cancelAll()、stop（）方法：

/**
* Cancels all requests in this queue for which the given filter applies.
* @param filter The filtering function to use
*/
public void cancelAll(RequestFilter filter) {
synchronized (mCurrentRequests) {
for (Request<?> request : mCurrentRequests) {
if (filter.apply(request)) {
request.cancel();
}
}
}
}

cancelAll()方法用于将当前的mCurrentRequests集合中全部进行标记取消，理论上只能在线程没开启的时候取消

/**
* Stops the cache and network dispatchers.
*/
public void stop() {
if (mCacheDispatcher != null) {
mCacheDispatcher.quit();
}
for (int i = 0; i < mDispatchers.length; i++) {
if (mDispatchers[i] != null) {
mDispatchers[i].quit();
}
}
}

stop（）方法则是调用线程执行quit()方法，理论上可以停止正在执行缓存和网络任务的线程

@see quit()

public void quit() {
mQuit = true;
interrupt();
}

quit()方法标记为true,使线程的while循环退出并调用Thread中的interrupt()方法中断线程。

5、看RequestQueue的构造

```
RequestQueue的核心构造器:
public RequestQueue(Cache cache, Network network, int threadPoolSize,
ResponseDelivery delivery) {
mCache = cache;
mNetwork = network;
mDispatchers = new NetworkDispatcher[threadPoolSize];
mDelivery = delivery;
}

```

传入缓存执行对象，Volley中的newRequestQueue()，

网络请求mNetworkQueue和缓存队列mCacheQueue都是 PriorityBlockingQueue对象 RequestQueue存储请求用的是set集合（HashSet）

其他备注

1、 LinkedList类实现了Queue接口

2、 锁就是so这个对象，谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以这样写程序，但当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它得是一个对象）来充当锁，代码块中对该对象有一些处理操作。

3、

//得到Android系统的版本

@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)

Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH

4、TrafficStats.setThreadStatsTag(request.getTrafficStatsTag());

5、Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

6、Request中有个isCancel()方法。取消请求，如果请求已经在进行了则不起作用。这个方法是请求还没执行时有作用。也就是说在线程已经开始run了。

7、Request基类中定义了错误监听，因为子类的错误监听都相同，成功的监听都不同，成功的监听结果有String,Json,Image等。

8、Request中有返回监听，有错误返回监听，成功监听有子类设置，有个接口为ResponseDelivery，用于传递监听的，其子类ExecutorDelivery用于绑定Request及其子类的监听与Response的。

9、

BlockingQueue<String> queue = new PriorityBlockingQueue();

这个队列对象相当于指针，对象作为参数传入方法后，改变值会同时在外面被改变；在RequestQueue类中的mNetWorkQueue和mCacheQueue都是这个类型的对象。

//TODO 还有其他的一些关键类再去了解