4、Volley解析(二),源码的深入分析一,缓存线程和网络请求线程

原创 2017年04月28日 15:21:26

前言

首先来看一下谷歌的官方流程图
这里写图片描述
从图中我们可以看出Volley工作的时候有三种线程,分别是主线程、请求线程、缓存线程,图中的流程大致如下:首先将请求放入缓存队列(队列中会根据优先级来排序),缓存线程将请求从缓存线程中取出,如果缓存存在,则将缓存的数据取出解析,传到主线程。如果不存在则将请求队列去执行网络请求。请求完成之后,再把结果发送给主线程。这里就是利用线程生产者-消费者模式

1. 源码的入口

分析某个开源项目的源码,首先要找到它的入口,然后再抽丝剥茧,逐步分析。这样思路会比较清晰。

//这个方法要做的工作是创建工作线程池的默认实例,并调用
 public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
        File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);

        String userAgent = "volley/0";
        try {
            String packageName = context.getPackageName();
            PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
            userAgent = packageName + "/" + info.versionCode;
        } catch (NameNotFoundException e) {
        }
        //如果没有限定stack,由系统自己判断使用哪种请求方式
        if (stack == null) {
            if (Build.VERSION.SDK_INT >= 9) {
            //adk版本在9或者以上,使用HttpURLConnection
            //它的API简单,体积较小,因而非常适用于Android项目。压缩和缓存机制可以有效地减少网络访问的流量,在提升速度和省电方面也起到了较大的作用。
                stack = new HurlStack();
            } else {
                // 在Android 2.2版本之前,HttpClient拥有较少的bug,因此使用它是最好的选择。       
                stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
            }
        }

        Network network = new BasicNetwork(stack);

        RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
        //
        queue.start();

        return queue;
    }

今天这一篇博客,先不去研究用哪种请求方式,先介绍各个线程的工作流程。
创建好了HttpStack之后,接下来又创建了一个Network对象,它是用于根据传入的HttpStack对象来处理网络请求的,紧接着new出一个RequestQueue对象,并调用它的start()方法进行启动,然后将RequestQueue返回。
看到这里我们肯定会疑问,start()到底做了什么工作,会不会和线程有关呢?下面我们就来看一下。

    public void start() {  
        //确保当前运行的任何调度都已停止。 
        stop();  
        // 创建缓存的调度器并启动(缓存线程)
        mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);  
        mCacheDispatcher.start();  
        // 创建网络请求的调度器,默认开启四条网络请求的线程
        for (int i = 0; i < mDispatchers.length; i++) {  
            NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,  
                    mCache, mDelivery);  
            mDispatchers[i] = networkDispatcher;  
            networkDispatcher.start();  
        }  
    }  

这里的CacheDispatcher和NetworkDispatcher都是继承自Thread的,也就是说当调用了satrt()之后,就会有五个线程一直在后台运行,不断等待网络请求的到来,其中CacheDispatcher是缓存线程,NetworkDispatcher是网络请求线程。

我们首先来看一下CacheDispatcher

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

        // Make a blocking call to initialize the cache.
        mCache.initialize();
        //死循环,一直在运行执行任务
        while (true) {
            try {

                //首先从mCacheQueue中取出一个任务,
                // at least one is available.
                final Request<?> request = mCacheQueue.take();
                request.addMarker("cache-queue-take");

                // 判断请求任务是否取消,取消了就跳出,进入下个循环。
                if (request.isCanceled()) {
                    request.finish("cache-discard-canceled");
                    continue;
                }

                // 取出缓存
                Cache.Entry entry = mCache.get(request.getCacheKey());
                //判断是否为空
                if (entry == null) {
                    request.addMarker("cache-miss");
                    // 如果为空,就将这个任务加入到网络请求的队列当中,这里就用到了生产者-消费者模式,此时缓存线程充当的是生产者对象。
                    mNetworkQueue.put(request);
                    //然后跳出循环
                    continue;
                }

                //如果缓存过期的话同样是将任务加入网络请求队列当中。然后跳出当前循环
                if (entry.isExpired()) {
                    request.addMarker("cache-hit-expired");
                    request.setCacheEntry(entry);
                    mNetworkQueue.put(request);
                    continue;
                }

                // 下面就是肯定存在缓存,浴室将缓存读取出来,解析。
                request.addMarker("cache-hit");
                Response<?> response = request.parseNetworkResponse(
                        new NetworkResponse(entry.data, entry.responseHeaders));
                request.addMarker("cache-hit-parsed");
                //如果缓存的数据不需要刷新
                if (!entry.refreshNeeded()) {
                    // 将数据发送到主线程
                    mDelivery.postResponse(request, response);
                } else {//刷新缓存
                    // Soft-expired cache hit. We can deliver the cached response,
                    // but we need to also send the request to the network for
                    // refreshing.
                    request.addMarker("cache-hit-refresh-needed");
                    request.setCacheEntry(entry);

                    // Mark the response as intermediate.
                    response.intermediate = true;

                    // Post the intermediate response back to the user and have
                    // the delivery then forward the request along to the network.
                    mDelivery.postResponse(request, response, new Runnable() {
                        @Override
                        public void run() {
                            try {//将任务添加到网络请求的队列
                                mNetworkQueue.put(request);
                            } catch (InterruptedException e) {
                                // Not much we can do about this.
                            }
                        }
                    });
                }

            } catch (InterruptedException e) {
                // We may have been interrupted because it was time to quit.
                if (mQuit) {
                    //循环结束,安全 
                    return;
                }

                continue;
            }
        }
    }

到这里相信大家已经对CacheDispatcher有了足够的了解,下面我们就来看看NetworkDispatcher 主要职责是什么代码如下


 @Override
    public void run() {
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        while (true) {
            long startTimeMs = SystemClock.elapsedRealtime();
            Request<?> request;
            try {
                // Take a request from the queue.
                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 the request was cancelled already, do not perform the
                // network request.
                if (request.isCanceled()) {
                    request.finish("network-discard-cancelled");
                    continue;
                }
//统计流量  
                addTrafficStatsTag(request);

                // Perform the network request.
                //从网络解析请求,获得响应  
                NetworkResponse networkResponse = mNetwork.performRequest(request);
                request.addMarker("network-http-complete");

                // If the server returned 304 AND we delivered a response already,
                // we're done -- don't deliver a second identical response.
                //支持304重定向
                if (networkResponse.notModified && request.hasHadResponseDelivered()) {
                    request.finish("not-modified");
                    continue;
                }

                // Parse the response here on the worker thread.
                //解析网络响应到本地  
                Response<?> response = request.parseNetworkResponse(networkResponse);
                request.addMarker("network-parse-complete");

                // Write to cache if applicable.
                // TODO: Only update cache metadata instead of entire record for 304s.
                //将数据缓存
                if (request.shouldCache() && response.cacheEntry != null) {
                    mCache.put(request.getCacheKey(), response.cacheEntry);
                    request.addMarker("network-cache-written");
                }

                // Post the response back.
                //将数据发送给主线程
                request.markDelivered();
                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.postError(request, volleyError);
            }
        }
    }

    private void parseAndDeliverNetworkError(Request<?> request, VolleyError error) {
        error = request.parseNetworkError(error);
        mDelivery.postError(request, error);
    }

这样 CacheDispatcher 和 NetworkDispatcher就构成了生产者和消费者模式,当然充当生产者的不仅仅是CacheDispatcher 线程,还有主线程。其实CacheDispatcher 和 NetworkDispatcher大部分逻辑都是相同的,理解了一个另一个就不难理解了。今天这篇博客就到这里,下篇将为大家分析具体的网络请求是怎么样的。

版权声明:本文为博主原创文章,未经博主允许不得转载。

volley框架有没用到线程池?

最近项目中使用到volley,自己就去网上学习volley并且研究了很长时间源码,网上有很多疑问关于volley到底有没有使用线程池?   今天我可以告诉你volley虽然没有用ThreadPoolE...
  • Jerry_1911
  • Jerry_1911
  • 2016年01月03日 20:04
  • 1917

Android volley 解析(四)之缓存篇

这是 volley 的第四篇 blog 了,写完这篇,volley 的大部分用法也都算写了一遍,所以暂时不会写 volley 的文章了,如果想看我前面写的文章,可以点这里 Android vol...
  • jxxfzgy
  • jxxfzgy
  • 2015年03月07日 08:56
  • 8762

Volley二次封装,实现网络请求缓存

Android目前很多同学使用Volley请求网络数据,但是Volley没有对请求过得数据进行缓存,因此需要我们自己手动缓存。 一下就是我的一种思路,仅供参考 NetWorkHelper---对...
  • zxm317122667
  • zxm317122667
  • 2015年11月04日 11:13
  • 4822

网络连接之——谷歌提供的通信框架Volley【避免创建多个线程对象】

参考:http://www.kwstu.com/ArticleView/kwstu_201441183134291.概述:如今,android应用不可避免会用到网络技术,而常用的就是HttpURLCo...
  • womengmengyan
  • womengmengyan
  • 2015年09月14日 10:06
  • 1201

Android Volley完全解析(四),带你从源码的角度理解Volley

经过前三篇文章的学习,Volley的用法我们已经掌握的差不多了,但是对于Volley的工作原理,恐怕有很多朋友还不是很清楚。因此,本篇文章中我们就来一起阅读一下Volley的源码,将它的工作流程整体地...
  • sinyu890807
  • sinyu890807
  • 2014年05月15日 09:39
  • 77274

Volley源码解析(三)网络请求流程

volley封装的很好,使用起来很方便,在一篇博客中,我们学些了volley进行网络请求的三个步骤,以及请求不同格式定义不同的Request,但是对Volley的源码我们还不是很清楚,就让我们一起来阅...
  • chengshuyuan_uestc
  • chengshuyuan_uestc
  • 2016年06月24日 19:10
  • 2892

双核心四线程变成单核心单线程,肿么办

一、事情起因:        在第二遍看操作系统的过程当中,看到了多处理器系统,当时比较好奇。总觉得这个东东应该指的就是我们平时所说的双核、四核。于是乎,百度一下。百度结果如下图所示。好奇心驱使,打开...
  • qq_26545305
  • qq_26545305
  • 2016年03月02日 19:07
  • 1482

【进阶android】Volley源码分析——Volley的线程

在上一篇文章中,我们主要分析了Volley一次网络请求的总体流程,并在此基础上初步分析了Request和RequestQueue两个Volley框架中较为重要的类。        而本片文章,将在上一...
  • xiaogutou1
  • xiaogutou1
  • 2015年07月27日 17:52
  • 941

OKHttp3源码分析<CacheThreadPool线程池异步请求任务的执行>

1.线程池的好处几乎所有需要异步操作或者并发执行任务的程序都可以使用线程池,三个好处: 降低资源消耗:通过重复利用已创建的线程降低线程创建和销毁造成的消耗; 提高响应速度:当任务到达的时...
  • Gpwner
  • Gpwner
  • 2017年03月06日 22:53
  • 1468

关于“设计4个线程,其中两个线程对j加1,另外两个线程对j减1”的问题

1、代码 public class Test { public static void main(String[] args) { Data data = new Data(); ...
  • vinegar93
  • vinegar93
  • 2016年05月19日 14:32
  • 2264
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:4、Volley解析(二),源码的深入分析一,缓存线程和网络请求线程
举报原因:
原因补充:

(最多只允许输入30个字)