Volley-NetworkDispatcher源码解析

/** 请求队列，是一个阻塞队列 */
private final BlockingQueue<Request<?>> mQueue;
/** 网络请求的具体实现类 */
private final Network mNetwork;
/** Volley缓存的操作类 */
private final Cache mCache;
/** Volley的响应分发类 */
private final ResponseDelivery mDelivery;
/** 请求线程的中断标志位 */
private volatile boolean mQuit = false;

 public NetworkDispatcher(BlockingQueue<Request<?>> queue,
            Network network, Cache cache,
            ResponseDelivery delivery) {
        mQueue = queue;
        mNetwork = network;
        mCache = cache;
        mDelivery = delivery;
}

@Override
    public void run() {
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        while (true) {
            long startTimeMs = SystemClock.elapsedRealtime();
            Request<?> request;
            try {
                // 从队列中获取一个请求，如果没有请求，则会一直阻塞 
                request = mQueue.take();
            } catch (InterruptedException e) {
                // We may have been interrupted because it was time to quit.
                if (mQuit) {
                    return;
                }
                continue;
            }

            try {
                request.addMarker("network-queue-take");
                
                //判断请求有没有取消，如果取消，则不必再继续  
                if (request.isCanceled()) {
                    request.finish("network-discard-cancelled");
                    continue;
                }
                //流量统计用的
                addTrafficStatsTag(request);

                // 调用mNetwork请求数据
                NetworkResponse networkResponse = mNetwork.performRequest(request);
                request.addMarker("network-http-complete");

                // 如果服务器返回一个未修改（304）的响应，并且这个请求已经发送过响应对象，不需要再继续，因为没改过  
                if (networkResponse.notModified && request.hasHadResponseDelivered()) {
                    //如果是相同的请求，那么服务器就返回一次响应
                    request.finish("not-modified");
                    continue;
                }

                // 解析响应数据，返回Response对象 
                Response<?> response = request.parseNetworkResponse(networkResponse);
                request.addMarker("network-parse-complete");

              // 根据request的shouldCache字段来判断是不是需要缓存，如果需要，则将其放到mCache中。 
                if (request.shouldCache() && response.cacheEntry != null) {
                    // 缓存数据
                    mCache.put(request.getCacheKey(), response.cacheEntry);
                    request.addMarker("network-cache-written");
                }

                // 标记请求已经被分发
                request.markDelivered();
                //调用 mDelivery将Response对象传回主线程进行UI的更新。  
                mDelivery.postResponse(request, response);
            } catch (VolleyError volleyError) {
                volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
                parseAndDeliverNetworkError(request, volleyError);
            } catch (Exception e) {
                VolleyLog.e(e, "Unhandled exception %s", e.toString());
                VolleyError volleyError = new VolleyError(e);
                volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
                //有错误，也会调用到mDelivery，将错误信息传回到主线程，进行提示  
                mDelivery.postError(request, volleyError);
            }
        }
}

//用于判断线程是否结束,用于退出线程
private volatile boolean mQuit = false;

//出线程
public void quit() {
    mQuit = true;
    interrupt();
}

while (true) {
    Request<?> request;
    try {
        request = mQueue.take();
    } catch (InterruptedException e) {
        if (mQuit) {
            return;
        }
        continue;
    }
}