Android网络框架volley学习(六)调度器CacheDispatcher简析

在前面的分析文章中，我们了解到，当发起一个请求时，首先加入到请求队列中，请求队列中是如何工作的呢？它会首先去缓存队列中取，如果不符合的话另开网络线程去执行这个请求操作。

源码路径RequestQueue#start

/**
     * Starts the dispatchers in this queue.
     */
    public void start() {
        // Make sure any currently running dispatchers are stopped.
        stop();  

        //缓存线程工作
        // Create the cache dispatcher and start it.
        mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
        mCacheDispatcher.start();

        //默认有4个网络线程工作
        // 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是如何工作的。

CacheDispatcher

顾名思义，这是一个缓存调度线程，用于处理走缓存的请求。首先看下它的变量。

成员变量

    /** 缓存请求队列 */
    private final BlockingQueue<Request<?>> mCacheQueue;

    /** 网络请求队列 */
    private final BlockingQueue<Request<?>> mNetworkQueue;

    /** 缓存类接口 */
    private final Cache mCache;

    /** 返回处理请求的结果 */
    private final ResponseDelivery mDelivery;

    /** 退出线程 */
    private volatile boolean mQuit = false;

    /** 等待请求管理类或者处理重复请求的管理类*/
    private final WaitingRequestManager mWaitingRequestManager;

接着进行初始化操作。

既然CacheDispatcher是一个线程，那么接着我们就来看下它的run方法。

@Override
    public void run() {
        if (DEBUG) VolleyLog.v("start new dispatcher");

       //设置优先级，略低于正常线程的优先级        
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

        //缓存线程初始化
        mCache.initialize();

        //循环工作
        while (true) {
            try {
                processRequest();
            } catch (InterruptedException e) {
                // We may have been interrupted because it was time to quit.
                if (mQuit) {
                    return;
                }
            }
        }
    }

这里面没有什么大动作，我们来看下里面的processRequest方法是干嘛的。由于这个方法太长，我们一步一步分析。

首先从缓存队列中取出请求，判断是否已经取消了。

final Request<?> request = mCacheQueue.take();
        request.addMarker("cache-queue-take");

        // If the request has been canceled, don't bother dispatching it.
        if (request.isCanceled()) {
            request.finish("cache-discard-canceled");
            return;
        }

接着从缓存中取出这个请求结果。如果不存在在这个请求结果的话，则加入到网络调度线程队列中去。

// 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.
            if (!mWaitingRequestManager.maybeAddToWaitingRequests(request)) {
                mNetworkQueue.put(request);
            }
            return;
        }

如果存在这条缓存结果时，继续往下走，然后判断是否过期了。如果过期了则同样加入到网络线程队列中去。

// If it is completely expired, just send it to the network.
        if (entry.isExpired()) {
            request.addMarker("cache-hit-expired");
            request.setCacheEntry(entry);
            if (!mWaitingRequestManager.maybeAddToWaitingRequests(request)) {
                mNetworkQueue.put(request);
            }
            return;
        }

接下来讲缓存的结果解析成response，

Response<?> response = request.parseNetworkResponse(
                new NetworkResponse(entry.data, entry.responseHeaders));

接着判断是否需要刷新，不需要的话则直接返回缓存结果，否则加入到网络缓存队列中去。

if (!entry.refreshNeeded()) {
            //不需要刷新，直接返回结果
            mDelivery.postResponse(request, response);
        } else {

            request.addMarker("cache-hit-refresh-needed");
            request.setCacheEntry(entry);
            // Mark the response as intermediate.
            response.intermediate = true;

            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 {

                mDelivery.postResponse(request, response);
            }
        }

这里面有个静态内部类WaitingRequestManager，我们来看下表示什么内容。

WaitingRequestManager

里面有个成员变量，说明表示存储重复请求的。

private final Map<String, List<Request<?>>> mWaitingRequests = new HashMap<>();

接着我们看上面用的方法maybeAddToWaitingRequests，字面意思就是可能需要保存到等待请求队列中去。

if (mWaitingRequests.containsKey(cacheKey)) {
                // There is already a request in flight. Queue up.
                List<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);
                if (stagedRequests == null) {
                    stagedRequests = new ArrayList<Request<?>>();
                }
                request.addMarker("waiting-for-response");
                stagedRequests.add(request);
                mWaitingRequests.put(cacheKey, stagedRequests);
                if (VolleyLog.DEBUG) {
                    VolleyLog.d("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);
                }
                return true;
            }  else {
                // Insert 'null' queue for this cacheKey, indicating there is now a request in
                // flight.
                mWaitingRequests.put(cacheKey, null);
                request.setNetworkRequestCompleteListener(this);
                if (VolleyLog.DEBUG) {
                    VolleyLog.d("new request, sending to network %s", cacheKey);
                }
                return false;
            }

首先判断这个集合中是否存在当前请求，如果存在的话则表示重复请求，则需要排队等待。

以上便是整个缓存请求的处理流程。借用网上的一张图来总结一下，图片原地址为Volley 源码解析