因为国内被墙,看起来不方便,转载下,原文地址:http://android-developers.blogspot.com/2010/07/multithreading-for-performance.html

Multithreading For Performance

 

[This post is by Gilles Debunne, an engineer in the Android group who loves to get multitasked. — Tim Bray]

A good practice in creating responsive applications is to make sure your main UI thread does the minimum amount of work. Any potentially long task that may hang your application should be handled in a different thread. Typical examples of such tasks are network operations, which involve unpredictable delays. Users will tolerate some pauses, especially if you provide feedback that something is in progress, but a frozen application gives them no clue.

In this article, we will create a simple image downloader that illustrates this pattern. We will populate a ListView with thumbnail images downloaded from the internet. Creating an asynchronous task that downloads in the background will keep our application fast.

An Image downloader

Downloading an image from the web is fairly simple, using the HTTP-related classes provided by the framework. Here is a possible implementation:

staticBitmap downloadBitmap(String url){
    finalAndroidHttpClient client =AndroidHttpClient.newInstance("Android");
    finalHttpGet getRequest =newHttpGet(url);     try{
        HttpResponse response = client.execute(getRequest);
        finalint statusCode = response.getStatusLine().getStatusCode();
        if(statusCode !=HttpStatus.SC_OK){
            Log.w("ImageDownloader","Error "+ statusCode +" while retrieving bitmap from "+ url);
            returnnull;
        }
       
        finalHttpEntity entity = response.getEntity();
        if(entity !=null){
            InputStream inputStream =null;
            try{
                inputStream = entity.getContent();
                finalBitmap bitmap =BitmapFactory.decodeStream(inputStream);
                return bitmap;
            }finally{
                if(inputStream !=null){
                    inputStream.close();  
                }
                entity.consumeContent();
            }
        }
    }catch(Exception e){
        // Could provide a more explicit error message for IOException or IllegalStateException
        getRequest.abort();
        Log.w("ImageDownloader","Error while retrieving bitmap from "+ url, e.toString());
    }finally{
        if(client !=null){
            client.close();
        }
    }
    returnnull;
}

A client and an HTTP request are created. If the request succeeds, the response entity stream containing the image is decoded to create the resulting Bitmap. Your applications' manifest must ask for the INTERNET to make this possible.

Note: a bug in the previous versions of BitmapFactory.decodeStream may prevent this code from working over a slow connection. Decode a new FlushedInputStream(inputStream) instead to fix the problem. Here is the implementation of this helper class:

staticclassFlushedInputStreamextendsFilterInputStream{
    publicFlushedInputStream(InputStream inputStream){
        super(inputStream);
    }     @Override
    publiclong skip(long n)throwsIOException{
        long totalBytesSkipped =0L;
        while(totalBytesSkipped < n){
            long bytesSkipped =in.skip(n - totalBytesSkipped);
            if(bytesSkipped ==0L){
                  intbyte= read();
                  if(byte<0){
                      break;  // we reached EOF
                  }else{
                      bytesSkipped =1;// we read one byte
                  }
           }
            totalBytesSkipped += bytesSkipped;
        }
        return totalBytesSkipped;
    }
}

This ensures that skip() actually skips the provided number of bytes, unless we reach the end of file.

If you were to directly use this method in your ListAdapter's getView method, the resulting scrolling would be unpleasantly jaggy. Each display of a new view has to wait for an image download, which prevents smooth scrolling.

Indeed, this is such a bad idea that the AndroidHttpClient does not allow itself to be started from the main thread. The above code will display "This thread forbids HTTP requests" error messages instead. Use the DefaultHttpClient instead if you really want to shoot yourself in the foot.

Introducing asynchronous tasks

The AsyncTask class provides one of the simplest ways to fire off a new task from the UI thread. Let's create anImageDownloader class which will be in charge of creating these tasks. It will provide a download method which will assign an image downloaded from its URL to an ImageView:

publicclassImageDownloader{

    publicvoid download(String url,ImageView imageView){
            BitmapDownloaderTask task =newBitmapDownloaderTask(imageView);
            task.execute(url);
        }
    }     /* class BitmapDownloaderTask, see below */
}

The BitmapDownloaderTask is the AsyncTask which will actually download the image. It is started using execute, which returns immediately hence making this method really fast which is the whole purpose since it will be called from the UI thread. Here is the implementation of this class:

classBitmapDownloaderTaskextendsAsyncTask<String,Void,Bitmap>{
    privateString url;
    privatefinalWeakReference<ImageView> imageViewReference;     publicBitmapDownloaderTask(ImageView imageView){
        imageViewReference =newWeakReference<ImageView>(imageView);
    }     @Override
    // Actual download method, run in the task thread
    protectedBitmap doInBackground(String...params){
         // params comes from the execute() call: params[0] is the url.
         return downloadBitmap(params[0]);
    }     @Override
    // Once the image is downloaded, associates it to the imageView
    protectedvoid onPostExecute(Bitmap bitmap){
        if(isCancelled()){
            bitmap =null;
        }         if(imageViewReference !=null){
            ImageView imageView = imageViewReference.get();
            if(imageView !=null){
                imageView.setImageBitmap(bitmap);
            }
        }
    }
}

The doInBackground method is the one which is actually run in its own process by the task. It simply uses the downloadBitmapmethod we implemented at the beginning of this article.

onPostExecute is run in the calling UI thread when the task is finished. It takes the resulting Bitmap as a parameter, which is simply associated with the imageView that was provided to download and was stored in the BitmapDownloaderTask. Note that this ImageView is stored as a WeakReference, so that a download in progress does not prevent a killed activity's ImageView from being garbage collected. This explains why we have to check that both the weak reference and the imageView are not null (i.e. were not collected) before using them in onPostExecute.

This simplified example illustrates the use on an AsyncTask, and if you try it, you'll see that these few lines of code actually dramatically improved the performance of the ListView which now scrolls smoothly. Read Painless threading for more details on AsyncTasks.

However, a ListView-specific behavior reveals a problem with our current implementation. Indeed, for memory efficiency reasons, ListView recycles the views that are displayed when the user scrolls. If one flings the list, a given ImageView object will be used many times. Each time it is displayed the ImageView correctly triggers an image download task, which will eventually change its image. So where is the problem? As with most parallel applications, the key issue is in the ordering. In our case, there's no guarantee that the download tasks will finish in the order in which they were started. The result is that the image finally displayed in the list may come from a previous item, which simply happened to have taken longer to download. This is not an issue if the images you download are bound once and for all to given ImageViews, but let's fix it for the common case where they are used in a list.

Handling concurrency

To solve this issue, we should remember the order of the downloads, so that the last started one is the one that will effectively be displayed. It is indeed sufficient for each ImageView to remember its last download. We will add this extra information in the ImageView using a dedicated Drawable subclass, which will be temporarily bind to the ImageView while the download is in progress. Here is the code of our DownloadedDrawable class:

staticclassDownloadedDrawableextendsColorDrawable{
    privatefinalWeakReference<BitmapDownloaderTask> bitmapDownloaderTaskReference;     publicDownloadedDrawable(BitmapDownloaderTask bitmapDownloaderTask){
        super(Color.BLACK);
        bitmapDownloaderTaskReference =
            newWeakReference<BitmapDownloaderTask>(bitmapDownloaderTask);
    }     publicBitmapDownloaderTask getBitmapDownloaderTask(){
        return bitmapDownloaderTaskReference.get();
    }
}

This implementation is backed by a ColorDrawable, which will result in the ImageView displaying a black background while its download is in progress. One could use a “download in progress” image instead, which would provide feedback to the user. Once again, note the use of a WeakReference to limit object dependencies.

Let's change our code to take this new class into account. First, the download method will now create an instance of this class and associate it with the imageView:

publicvoid download(String url,ImageView imageView){
     if(cancelPotentialDownload(url, imageView)){
         BitmapDownloaderTask task =newBitmapDownloaderTask(imageView);
         DownloadedDrawable downloadedDrawable =newDownloadedDrawable(task);
         imageView.setImageDrawable(downloadedDrawable);
         task.execute(url, cookie);
     }
}

The cancelPotentialDownload method will stop the possible download in progress on this imageView since a new one is about to start. Note that this is not sufficient to guarantee that the newest download is always displayed, since the task may be finished, waiting in its onPostExecute method, which may still may be executed after the one of this new download.

privatestaticboolean cancelPotentialDownload(String url,ImageView imageView){
    BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);     if(bitmapDownloaderTask !=null){
        String bitmapUrl = bitmapDownloaderTask.url;
        if((bitmapUrl ==null)||(!bitmapUrl.equals(url))){
            bitmapDownloaderTask.cancel(true);
        }else{
            // The same URL is already being downloaded.
            returnfalse;
        }
    }
    returntrue;
}

cancelPotentialDownload uses the cancel method of the AsyncTask class to stop the download in progress. It returns truemost of the time, so that the download can be started in download. The only reason we don't want this to happen is when a download is already in progress on the same URL in which case we let it continue. Note that with this implementation, if an ImageView is garbage collected, its associated download is not stopped. A RecyclerListener might be used for that.

This method uses a helper getBitmapDownloaderTask function, which is pretty straigthforward:

privatestaticBitmapDownloaderTask getBitmapDownloaderTask(ImageView imageView){
    if(imageView !=null){
        Drawable drawable = imageView.getDrawable();
        if(drawable instanceofDownloadedDrawable){
            DownloadedDrawable downloadedDrawable =(DownloadedDrawable)drawable;
            return downloadedDrawable.getBitmapDownloaderTask();
        }
    }
    returnnull;
}

Finally, onPostExecute has to be modified so that it will bind the Bitmap only if this ImageView is still associated with thisdownload process:

if(imageViewReference !=null){
    ImageView imageView = imageViewReference.get();
    BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);
    // Change bitmap only if this process is still associated with it
    if(this== bitmapDownloaderTask){
        imageView.setImageBitmap(bitmap);
    }
}

With these modifications, our ImageDownloader class provides the basic services we expect from it. Feel free to use it or the asynchronous pattern it illustrates in your applications to ensure their responsiveness.

Demo

The source code of this article is available online on Google Code. You can switch between and compare the three different implementations that are described in this article (no asynchronous task, no bitmap to task association and the final correct version). Note that the cache size has been limited to 10 images to better demonstrate the issues.

Future work

This code was simplified to focus on its parallel aspects and many useful features are missing from our implementation. TheImageDownloader class would first clearly benefit from a cache, especially if it is used in conjuction with a ListView, which will probably display the same image many times as the user scrolls back and forth. This can easily be implemented using a Least Recently Used cache backed by a LinkedHashMap of URL to Bitmap SoftReferences. More involved cache mechanism could also rely on a local disk storage of the image. Thumbnails creation and image resizing could also be added if needed.

Download errors and time-outs are correctly handled by our implementation, which will return a null Bitmap in these case. One may want to display an error image instead.

Our HTTP request is pretty simple. One may want to add parameters or cookies to the request as required by certain web sites.

The AsyncTask class used in this article is a really convenient and easy way to defer some work from the UI thread. You may want to use the Handler class to have a finer control on what you do, such as controlling the total number of download threads which are running in parallel in this case.

[转]Android图片下载的更多相关文章

  1. picasso_强大的Android图片下载缓存库

    tag: android pic skill date: 2016/07/09 title: picasso-强大的Android图片下载缓存库 [本文转载自:泡在网上的日子 参考:http://bl ...

  2. 毕加索的艺术——Picasso,一个强大的Android图片下载缓存库,OkHttpUtils的使用,二次封装PicassoUtils实现微信精选

    毕加索的艺术--Picasso,一个强大的Android图片下载缓存库,OkHttpUtils的使用,二次封装PicassoUtils实现微信精选 官网: http://square.github.i ...

  3. picasso-强大的Android图片下载缓存库

    编辑推荐:稀土掘金,这是一个针对技术开发者的一个应用,你可以在掘金上获取最新最优质的技术干货,不仅仅是Android知识.前端.后端以至于产品和设计都有涉猎,想成为全栈工程师的朋友不要错过! pica ...

  4. Android图片下载以及缓存框架

    实际开发中进行图片下载以及缓存的框架 介绍一下开发中常见图片加载框架的使用和对比一下优缺点. 1.Picasso 框架 在Android中开发,常需要从远程获取图片并显示在客户端,当然我们可以使用原生 ...

  5. Android图片下载到本地,系统图库不显示

    可能大家都知道我们下载图片到Android手机的时候,然后调用系统图库打开图片,提示"找不到指定项". 那是因为我们插入的图片还没有更新的缘故,所以只要将图片插入系统图库,之后发条 ...

  6. 如何使用picasso 对Android图片下载缓存

    相比较其他,picasso的图片缓存更加简单一些,他只需要一行代码就可以表述:导入相关jar包 Picasso.with(context).load("图片路径").into(Im ...

  7. 具体解说Android图片下载框架UniversialImageLoader之内存缓存(三)

    前面的两篇文章着重介绍的是磁盘缓存,这篇文章主要是解说一下内存缓存.对于内存缓存.也打算分两篇文章来进行解说.在这一篇文章中,我们主要是关注三个类, MemoryCache.BaseMemoryCac ...

  8. Android异步下载图片并且缓存图片到本地

    Android异步下载图片并且缓存图片到本地 在Android开发中我们经常有这样的需求,从服务器上下载xml或者JSON类型的数据,其中包括一些图片资源,本demo模拟了这个需求,从网络上加载XML ...

  9. 【转】Picasso – Android系统的图片下载和缓存类库

    来源:http://blog.chengyunfeng.com/?p=492 另一篇参考:http://blog.csdn.net/xu_fu/article/details/17043231 Pic ...

随机推荐

  1. about greenplum collection tool

    three collection tool for greenplum:pstack.strace.gcore.                                            ...

  2. 基于LINUX的多功能聊天室

    原文:基于LINUX的多功能聊天室 基于LINUX的多功能聊天室 其实这个项目在我电脑已经躺了多时,最初写完项目规划后,我就认认真真地去实现了它,后来拿着这个项目区参加了面试,同样面试官也拿这个项目来 ...

  3. OCP读书笔记(21) - 题库(ExamA)

    Administer ASM disk groupsBack up the recovery catalogConfigure backup settingsConfigure, Monitor Fl ...

  4. VC编程 快捷键增加的几种方式

    VB运行时菜单字母的下划线消失 vc 给菜单增加快捷键RT给Menu里面的 文件 帮助 查看 等功能键加上一个快捷方式.比如按Ctrl+F1 就弹出查看下面的子功能.------解决方案------- ...

  5. 小记 js unicode 编码解析

    原文:小记 js unicode 编码解析 var str = "\\u6211\\u662Funicode\\u7F16\\u7801"; 关于这样的数据转换为中文问题,常用的两 ...

  6. MyEclipse2014 设备 checkstyle、PMD、findbugs 最简单的方法 详细说明

    最近的实验需要的代码审查和应用程序性能优化.在需求MyEclipse安装某些插件,由于如今的MyEclipse版本号和大多数教程的不一样了,一些安装选项也已经改变,所以安装起来非常费事,通过不断的尝试 ...

  7. ASP.NET MVC2.0 自定义filters

    今天大家共同学习下ASP.NET MVC2.0中自定义filters,这一节主要学习下ActionFilterAttribute, ActionFilterAttribute继承IActionFilt ...

  8. oracle_连接数_查看

    查看oracle数据库的连接数以及用户   .查询oracle的连接数 select count(*) from v$session; .查询oracle的并发连接数 select count(*) ...

  9. 【Java编码准则】の #12不要使用不安全或者强度弱的加密算法

    安全性要求高的应用程序必须避免使用不安全的或者强度弱的加密算法,现代计算机的计算能力使得攻击者通过暴力破解能够攻破强度弱的算法.比如,数据加密标准算法DES是极度不安全的,使用类似EFF(Electr ...

  10. 转载使用Flurl制作可复用的分页组件

    使用Flurl制作可复用的分页组件 使用ASP.NET MVC查询时,一直使用MvcPaging组件,虽然需要自定义MvcPaging.Pager才能达到我想要的效果,但在没有较好的URL库时,还是这 ...