2. 程式人生 > >Android非同步載入影象小結

Android非同步載入影象小結

阿新 • • 發佈：2019-01-26

研究了android從網路上非同步載入影象，現總結如下：

（1）由於android UI更新支援單一執行緒原則，所以從網路上取資料並更新到介面上，為了不阻塞主執行緒首先可能會想到以下方法。

     在主執行緒中new 一個Handler物件，載入影象方法如下所示

    private void loadImage(final String url, final int id) {
         handler.post(new Runnable() {
                public void run() {
                    Drawable drawable = null;
                    try {
                        drawable = Drawable.createFromStream(new URL(url).openStream(), "image.png");
                    } catch (IOException e) {
                    }
                    ((ImageView) LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
                }
            });
    }

上面這個方法缺點很顯然，經測試，如果要載入多個圖片，這並不能實現非同步載入，而是等到所有的圖片都載入完才一起顯示，因為它們都執行在一個執行緒中。

然後，我們可以簡單改進下，將Handler+Runnable模式改為Handler+Thread+Message模式不就能實現同時開啟多個執行緒嗎？

（2）在主執行緒中new 一個Handler物件，程式碼如下：

    final Handler handler2=new Handler(){
          @Override
          public void handleMessage(Message msg) {
             ((ImageView) LazyLoadImageActivity.this.findViewById(msg.arg1)).setImageDrawable((Drawable)msg.obj);
          }
      };

    對應載入影象程式碼如下：

  //採用handler+Thread模式實現多執行緒非同步載入
     private void loadImage2(final String url, final int id) {
         Thread thread = new Thread(){
             @Override
             public void run() {
               Drawable drawable = null;
                    try {
                        drawable = Drawable.createFromStream(new URL(url).openStream(), "image.png");
                    } catch (IOException e) {
                    }

                Message message= handler2.obtainMessage() ;
                 message.arg1 = id;
                 message.obj = drawable;
                 handler2.sendMessage(message);
             }
         };
         thread.start();
         thread = null;
    }

這樣就簡單實現了非同步載入了。細想一下，還可以優化的，比如引入執行緒池、引入快取等，我們先介紹執行緒池。

（3）引入ExecutorService介面，於是程式碼可以優化如下：

       在主執行緒中加入：private ExecutorService executorService = Executors.newFixedThreadPool(5);   

       對應載入影象方法更改如下：

      // 引入執行緒池來管理多執行緒
    private void loadImage3(final String url, final int id) {
        executorService.submit(new Runnable() {
            public void run() {
                try {
                    final Drawable drawable = Drawable.createFromStream(new URL(url).openStream(), "image.png");
                    handler.post(new Runnable() {

                        public void run() {
                            ((ImageView) LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
                        }
                    });
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
    }

（4）為了更方便使用我們可以將非同步載入影象方法封裝一個類，對外界只暴露一個方法即可，考慮到效率問題我們可以引入記憶體快取機制，做法是

建立一個HashMap，其鍵（key）為載入影象url，其值（value）是影象物件Drawable。先看一下我們封裝的類

public class AsyncImageLoader3 {
   //為了加快速度，在記憶體中開啟快取（主要應用於重複圖片較多時，或者同一個圖片要多次被訪問，比如在ListView時來回滾動）
    public Map<String, SoftReference<Drawable>> imageCache = new HashMap<String, SoftReference<Drawable>>();
    private ExecutorService executorService = Executors.newFixedThreadPool(5);    //固定五個執行緒來執行任務
    private final Handler handler=new Handler();

     /**
     *
     * @param imageUrl     影象url地址
     * @param callback     回撥介面
     * @return     返回記憶體中快取的影象，第一次載入返回null
     */
    public Drawable loadDrawable(final String imageUrl, final ImageCallback callback) {
        //如果快取過就從快取中取出資料
        if (imageCache.containsKey(imageUrl)) {
            SoftReference<Drawable> softReference = imageCache.get(imageUrl);
            if (softReference.get() != null) {
                return softReference.get();
            }
        }
        //快取中沒有影象，則從網路上取出資料，並將取出的資料快取到記憶體中
         executorService.submit(new Runnable() {
            public void run() {
                try {
                    final Drawable drawable = Drawable.createFromStream(new URL(imageUrl).openStream(), "image.png");

                    imageCache.put(imageUrl, new SoftReference<Drawable>(drawable));

                    handler.post(new Runnable() {
                        public void run() {
                           callback.imageLoaded(drawable);
                        }
                    });
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
        return null;
    }
     //從網路上取資料方法
    protected Drawable loadImageFromUrl(String imageUrl) {
        try {
            return Drawable.createFromStream(new URL(imageUrl).openStream(), "image.png");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    //對外界開放的回撥介面
    public interface ImageCallback {
        //注意 此方法是用來設定目標物件的影象資源
        public void imageLoaded(Drawable imageDrawable);
    }
}這樣封裝好後使用起來就方便多了。在主執行緒中首先要引入AsyncImageLoader3 物件，然後直接呼叫其loadDrawable方法即可，需要注意的是ImageCallback介面的imageLoaded方法是唯一可以把載入的影象設定到目標ImageView或其相關的元件上。

在主執行緒呼叫程式碼：

  先例項化物件 private AsyncImageLoader3 asyncImageLoader3 = new AsyncImageLoader3();

  呼叫非同步載入方法：

//引入執行緒池，並引入記憶體快取功能,並對外部呼叫封裝了介面，簡化呼叫過程
    private void loadImage4(final String url, final int id) {
          //如果快取過就會從快取中取出影象，ImageCallback介面中方法也不會被執行
         Drawable cacheImage = asyncImageLoader.loadDrawable(url,new AsyncImageLoader.ImageCallback() {
             //請參見實現：如果第一次載入url時下面方法會執行
             public void imageLoaded(Drawable imageDrawable) {
               ((ImageView) findViewById(id)).setImageDrawable(imageDrawable);
             }
         });
        if(cacheImage!=null){
          ((ImageView) findViewById(id)).setImageDrawable(cacheImage);
        }
    }

（5）同理，下面也給出採用Thread+Handler+MessageQueue+記憶體快取程式碼，原則同（4），只是把執行緒池換成了Thread+Handler+MessageQueue模式而已。程式碼如下：

public class AsyncImageLoader {
   //為了加快速度，加入了快取（主要應用於重複圖片較多時，或者同一個圖片要多次被訪問，比如在ListView時來回滾動）
    private Map<String, SoftReference<Drawable>> imageCache = new HashMap<String, SoftReference<Drawable>>();

     /**
     *
     * @param imageUrl     影象url地址
     * @param callback     回撥介面
     * @return     返回記憶體中快取的影象，第一次載入返回null
     */
    public Drawable loadDrawable(final String imageUrl, final ImageCallback callback) {
        //如果快取過就從快取中取出資料
        if (imageCache.containsKey(imageUrl)) {
            SoftReference<Drawable> softReference = imageCache.get(imageUrl);
            if (softReference.get() != null) {
                return softReference.get();
            }
        }

        final Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                callback.imageLoaded((Drawable) msg.obj);
            }
        };
        new Thread() {
            public void run() {
                Drawable drawable = loadImageFromUrl(imageUrl);
                imageCache.put(imageUrl, new SoftReference<Drawable>(drawable));
                handler.sendMessage(handler.obtainMessage(0, drawable));

            }

        }.start();
        /*
        下面註釋的這段程式碼是Handler的一種代替方法
         */
//        new AsyncTask() {
//            @Override
//            protected Drawable doInBackground(Object... objects) {
//                  Drawable drawable = loadImageFromUrl(imageUrl);
//                imageCache.put(imageUrl, new SoftReference<Drawable>(drawable));
//                return  drawable;
//            }
//
//            @Override
//            protected void onPostExecute(Object o) {
//                  callback.imageLoaded((Drawable) o);
//            }
//        }.execute();
        return null;
    }

    protected Drawable loadImageFromUrl(String imageUrl) {
        try {
            return Drawable.createFromStream(new URL(imageUrl).openStream(), "src");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    //對外界開放的回撥介面
    public interface ImageCallback {
        public void imageLoaded(Drawable imageDrawable);
    }
}

至此，非同步載入就介紹完了，下面給出的程式碼為測試用的完整程式碼：

package com.bshark.supertelphone.activity;

import android.app.Activity;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.widget.ImageView;
import com.bshark.supertelphone.R;
import com.bshark.supertelphone.ui.adapter.util.AsyncImageLoader;
import com.bshark.supertelphone.ui.adapter.util.AsyncImageLoader3;

import java.io.IOException;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class LazyLoadImageActivity extends Activity {
       final Handler handler=new Handler();
      final Handler handler2=new Handler(){
          @Override
          public void handleMessage(Message msg) {
             ((ImageView) LazyLoadImageActivity.this.findViewById(msg.arg1)).setImageDrawable((Drawable)msg.obj);
          }
      };
 private ExecutorService executorService = Executors.newFixedThreadPool(5);    //固定五個執行緒來執行任務
    private AsyncImageLoader asyncImageLoader = new AsyncImageLoader();
    private AsyncImageLoader3 asyncImageLoader3 = new AsyncImageLoader3();

 @Override
 protected void onDestroy() {
  executorService.shutdown();
  super.onDestroy();
 }
    //執行緒載入影象基本原理
    private void loadImage(final String url, final int id) {
         handler.post(new Runnable() {
                public void run() {
                    Drawable drawable = null;
                    try {
                        drawable = Drawable.createFromStream(new URL(url).openStream(), "image.png");
                    } catch (IOException e) {
                    }
                    ((ImageView) LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
                }
            });
    }
     //採用handler+Thread模式實現多執行緒非同步載入
     private void loadImage2(final String url, final int id) {
         Thread thread = new Thread(){
             @Override
             public void run() {
               Drawable drawable = null;
                    try {
                        drawable = Drawable.createFromStream(new URL(url).openStream(), "image.png");
                    } catch (IOException e) {
                    }

                Message message= handler2.obtainMessage() ;
                 message.arg1 = id;
                 message.obj = drawable;
                 handler2.sendMessage(message);
             }
         };
         thread.start();
         thread = null;
    }
    // 引入執行緒池來管理多執行緒
    private void loadImage3(final String url, final int id) {
        executorService.submit(new Runnable() {
            public void run() {
                try {
                    final Drawable drawable = Drawable.createFromStream(new URL(url).openStream(), "image.png");
                    handler.post(new Runnable() {

                        public void run() {
                            ((ImageView) LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
                        }
                    });
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
    }
    //引入執行緒池，並引入記憶體快取功能,並對外部呼叫封裝了介面，簡化呼叫過程
    private void loadImage4(final String url, final int id) {
          //如果快取過就會從快取中取出影象，ImageCallback介面中方法也不會被執行
         Drawable cacheImage = asyncImageLoader.loadDrawable(url,new AsyncImageLoader.ImageCallback() {
             //請參見實現：如果第一次載入url時下面方法會執行
             public void imageLoaded(Drawable imageDrawable) {
               ((ImageView) findViewById(id)).setImageDrawable(imageDrawable);
             }
         });
        if(cacheImage!=null){
          ((ImageView) findViewById(id)).setImageDrawable(cacheImage);
        }
    }

    //採用Handler+Thread+封裝外部介面
    private void loadImage5(final String url, final int id) {
          //如果快取過就會從快取中取出影象，ImageCallback介面中方法也不會被執行
         Drawable cacheImage = asyncImageLoader3.loadDrawable(url,new AsyncImageLoader3.ImageCallback() {
             //請參見實現：如果第一次載入url時下面方法會執行
             public void imageLoaded(Drawable imageDrawable) {
               ((ImageView) findViewById(id)).setImageDrawable(imageDrawable);
             }
         });
        if(cacheImage!=null){
                    ((ImageView) findViewById(id)).setImageDrawable(cacheImage);
        }
    }


}

xml檔案大致如下：

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:layout_width="fill_parent"
              android:orientation="vertical"
              android:layout_height="fill_parent" >
  <ImageView android:id="@+id/image1" android:layout_height="wrap_content" android:layout_width="fill_parent"></ImageView>
   <ImageView android:id="@+id/image2" android:layout_height="wrap_content" android:layout_width="fill_parent"></ImageView>
    <ImageView android:id="@+id/image3" android:layout_height="wrap_content" android:layout_width="fill_parent"></ImageView>
    <ImageView android:id="@+id/image5" android:layout_height="wrap_content" android:layout_width="fill_parent"></ImageView>
    <ImageView android:id="@+id/image4" android:layout_height="wrap_content" android:layout_width="fill_parent"></ImageView>
</LinearLayout>

相關推薦

Android非同步載入影象小結

研究了android從網路上非同步載入影象，現總結如下： （1）由於android UI更新支援單一執行緒原則，所以從網路上取資料並更新到介面上，為了不阻塞主執行緒首先可能會想到以下方法。      在主執行緒中new 一個Handler物件，載入影象方法如下所示     private void load

演化理解 Android 非同步載入圖片

                在學習"Android非同步載入影象小結"這篇文章時, 發現有些地方沒寫清楚，我就根據我的理解，把這篇文章的程式碼重寫整理了一遍，下面就是我的整理。  下面測試使用的layout檔案：  簡單來說就是 LinearLayout 佈局，其下放了5個ImageView。     &

Android非同步載入AsyncTask詳解

曾看見有人說過，覺得很有道理，分享一下：  技術分為術和道兩種：  （1）具體做事的方法是術；  （2）做事的原理和原則是道；       最近專案發現個重大問題，結果打log跟蹤查是AsyncTask

Android 非同步載入圖片-LruCache和SD卡或手機快取-三級快取原理載入圖片

非同步載入圖片的例子，網上也比較多，大部分用了HashMap<String, SoftReference<Drawable>> imageCache ，但是現在已經不再推薦使用這種方式了，因為從 Android 2.3 (API Level 9)開始，垃圾回

Android 非同步載入解決方案

from http://www.open-open.com/lib/view/open1345017746897.html Android的Lazy Load主要體現在網路資料（圖片）非同步載入、資料庫查詢、複雜業務邏輯處理以及費時任務操作導致的非同步處理等方面。在介紹An

Android非同步載入網路圖片

Android圖片的非同步載入，主要原理： 載入圖片時先檢視快取中時候存在該圖片，如果存在則返回該圖片，否則先載入載一個預設的佔位圖片，同時建立一個通過網路獲取圖片的任務並新增，任務完成後放鬆訊息給主執行緒更新介面。 使用方法： Asyn

android非同步載入

本篇部落格總結了慕課網關於非同步載入圖片的知識要點，和大家一起分享，有感覺聽得不連貫的可以來看看。 看完本篇部落格，你將學習到下面的知識： 1.怎樣將一個url（也可以說是一個InputStream）轉換為一個json字串資訊。 2.怎樣運用外掛寫一個我認為完美的mode

Android非同步載入（UI重新整理）

指切正題，為何要選擇非同步載入？ 由於UI執行緒（也可叫主縣城執行緒）負責處理使用者輸入事件（TP事件，顯示事件等），直接與使用者互動，如果UI執行緒阻塞，直接會影響使用者的體驗效果，嚴重的會報ANR錯誤。所以我們需要把耗時操作移出主執行緒，在子執行緒中進行處理。 下面羅

Android非同步載入全解析之Bitmap

public static OutputStream decodeBitmap(String path) { BitmapFactory.Options opts = new BitmapFactory.Options(); opts.inJustDecodeBounds

Android非同步載入(慕課網學習筆記)

最近看了慕課網的教學視訊,這裡記錄一下學習筆記. 學習視訊地址:http://www.imooc.com/learn/406 視訊完成的小例子很簡單,就是展示一個帶圖片的列表.如下圖所示: 首先把MainActivity的佈局,ListView的It

Android 非同步載入網路圖片到ImageView （Hnadler）

首先建立一個Handler private Handler handler=new Handler(){ @Override public void handleMessage(Mes

Android多執行緒分析之一：使用Thread非同步下載影象

Android多執行緒分析之一：使用Thread非同步下載影象 羅朝輝 (http://blog.csdn.net/kesalin) CC 許可，轉載請註明出處 打算整理一下對 Android Framework 中多執行緒相關知識的理解，主要集中在 Fra

Android-LoaderManager非同步載入資料庫資料

LoaderManager非同步載入資料庫資料，是在(Activity/fragment/其他UI等) 載入大量的本地Database庫表資料，由於資料大在載入過程中會導致UI執行緒阻塞，導致使用者體驗不好，Android為來解決這個問題，就設計了LoaderManager非同步載入資料庫資料  

Android中的AsyncTask非同步載入圖片

AsyncTask簡介： AsyncTask的特點是任務在主執行緒之外執行，而回調方法是在主執行緒中執行，這就有效地避免了使用Handler帶來的麻煩。 閱讀 AsyncTask的原始碼可知，AsyncTask是使用java.util.concurrent 框架來管理執行緒

Android ListView效能優化，非同步載入圖片

<span style="font-size:14px;"><span style="font-size:14px;">public static void initImageLoader(Context context) { personOptions = new D

Android通過AsyncTask與ThreadPool（執行緒池）兩種方式非同步載入大量資料的分析與對比

如果您認為本部落格不錯，讀後覺得有收穫，不妨打賞讚助我一下，讓我有動力繼續寫出高質量的部落格。 贈人玫瑰，手有餘香。分享技術，傳遞快樂。 有心課堂，傳遞的不僅僅是技術！ QQ交流群：250468947 有心課堂會員，請加入VIP QQ交流

Android實現圖片快取與非同步載入

ImageManager2這個類具有非同步從網路下載圖片，從sd讀取本地圖片，記憶體快取，硬碟快取，圖片使用動畫漸現等功能，已經將其應用在包含大量圖片的應用中一年多，沒有出現oom。 Android程式常常會記憶體溢位，網上也有很多解決方案，如軟引用，手動呼叫recycle

android 視訊的縮圖 快取機制和 非同步載入縮圖

在這次的工作開發專案中，涉及到一個視訊縮圖的視訊列表；這個在大家看來，製作視訊縮圖就是兩行程式碼就搞定的事。確實是這樣的，百度一下，每個帖子都知道製作視訊縮圖的方法，在這裡確實也是一樣的，但是我要實現的是讓縮圖 在ListView上顯示，而且不會出現卡頓，其實也

Android批量圖片載入經典系列——使用xutil框架快取、非同步載入網路圖片

一、問題描述 　　為提高圖片載入的效率，需要對圖片的採用快取和非同步載入策略，編碼相對比較複雜，實際上有一些優秀的框架提供瞭解決方案，比如近期在git上比較活躍的xutil框架 　　Xutil框架提供了四大模組： 1、  DbUtil模組：採用ORM機制簡化Sqlite操作，

Android批量圖片載入經典系列——採用二級快取、非同步載入網路圖片

public class AsyncImageLoader{ private MemoryCache mMemoryCache;//記憶體快取 private FileCache mFileCache;//檔案快取 private ExecutorService mExecu