Android App中實(shí)現(xiàn)圖片異步加載的實(shí)例分享

更新時(shí)間：2016年04月19日 15:34:18 作者：鴻洋_

這篇文章主要介紹了Android App中實(shí)現(xiàn)圖片異步加載的實(shí)例分享,這樣GridView在加載大量圖片時(shí)便可以延時(shí)分布顯示,需要的朋友可以參考下

一、概述
一般大量圖片的加載，比如GridView實(shí)現(xiàn)手機(jī)的相冊功能，一般會(huì)用到LruCache，線程池，任務(wù)隊(duì)列等；那么異步消息處理可以用哪呢？
1、用于UI線程當(dāng)Bitmap加載完成后更新ImageView
2、在圖片加載類初始化時(shí)，我們會(huì)在一個(gè)子線程中維護(hù)一個(gè)Loop實(shí)例，當(dāng)然子線程中也就有了MessageQueue，Looper會(huì)一直在那loop停著等待消息的到達(dá)，當(dāng)有消息到達(dá)時(shí)，從任務(wù)隊(duì)列按照隊(duì)列調(diào)度的方式（FIFO,LIFO等），取出一個(gè)任務(wù)放入線程池中進(jìn)行處理。
簡易的一個(gè)流程：當(dāng)需要加載一張圖片，首先把加載圖片加入任務(wù)隊(duì)列，然后使用loop線程（子線程）中的hander發(fā)送一個(gè)消息，提示有任務(wù)到達(dá)，loop()（子線程）中會(huì)接著取出一個(gè)任務(wù)，去加載圖片，當(dāng)圖片加載完成，會(huì)使用UI線程的handler發(fā)送一個(gè)消息去更新UI界面。
說了這么多，大家估計(jì)也覺得云里來霧里去的，下面看實(shí)際的例子。

二、圖庫功能的實(shí)現(xiàn)
該程序首先掃描手機(jī)中所有包含圖片的文件夾，最終選擇圖片最多的文件夾，使用GridView顯示其中的圖片

1、布局文件

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" > 
 
 <GridView 
  android:id="@+id/id_gridView" 
  android:layout_width="match_parent" 
  android:layout_height="match_parent" 
  android:cacheColorHint="@android:color/transparent" 
  android:columnWidth="90dip" 
  android:gravity="center" 
  android:horizontalSpacing="20dip" 
  android:listSelector="@android:color/transparent" 
  android:numColumns="auto_fit" 
  android:stretchMode="columnWidth" 
  android:verticalSpacing="20dip" > 
 </GridView> 
 
</RelativeLayout>

布局文件相當(dāng)簡單就一個(gè)GridView
2、MainActivity

package com.example.zhy_handler_imageloader; 
 
import java.io.File; 
import java.io.FilenameFilter; 
import java.util.Arrays; 
import java.util.HashSet; 
import java.util.List; 
 
import android.app.Activity; 
import android.app.ProgressDialog; 
import android.content.ContentResolver; 
import android.database.Cursor; 
import android.net.Uri; 
import android.os.Bundle; 
import android.os.Environment; 
import android.os.Handler; 
import android.provider.MediaStore; 
import android.widget.GridView; 
import android.widget.ImageView; 
import android.widget.ListAdapter; 
import android.widget.Toast; 
 
public class MainActivity extends Activity 
{ 
 private ProgressDialog mProgressDialog; 
 private ImageView mImageView; 
  
 /** 
  * 存儲(chǔ)文件夾中的圖片數(shù)量 
  */ 
 private int mPicsSize; 
 /** 
  * 圖片數(shù)量最多的文件夾 
  */ 
 private File mImgDir; 
 /** 
  * 所有的圖片 
  */ 
 private List<String> mImgs; 
 
 private GridView mGirdView; 
 private ListAdapter mAdapter; 
 /** 
  * 臨時(shí)的輔助類，用于防止同一個(gè)文件夾的多次掃描 
  */ 
 private HashSet<String> mDirPaths = new HashSet<String>(); 
 
 private Handler mHandler = new Handler() 
 { 
  public void handleMessage(android.os.Message msg) 
  { 
   mProgressDialog.dismiss(); 
   mImgs = Arrays.asList(mImgDir.list(new FilenameFilter() 
   { 
    @Override 
    public boolean accept(File dir, String filename) 
    { 
     if (filename.endsWith(".jpg")) 
      return true; 
     return false; 
    } 
   })); 
   /** 
    * 可以看到文件夾的路徑和圖片的路徑分開保存，極大的減少了內(nèi)存的消耗； 
    */ 
   mAdapter = new MyAdapter(getApplicationContext(), mImgs, 
     mImgDir.getAbsolutePath()); 
   mGirdView.setAdapter(mAdapter); 
  }; 
 }; 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) 
 { 
  super.onCreate(savedInstanceState); 
  setContentView(R.layout.activity_main); 
  mGirdView = (GridView) findViewById(R.id.id_gridView); 
  getImages(); 
 
 } 
 
 /** 
  * 利用ContentProvider掃描手機(jī)中的圖片，此方法在運(yùn)行在子線程中 完成圖片的掃描，最終獲得jpg最多的那個(gè)文件夾 
  */ 
 private void getImages() 
 { 
  if (!Environment.getExternalStorageState().equals( 
    Environment.MEDIA_MOUNTED)) 
  { 
   Toast.makeText(this, "暫無外部存儲(chǔ)", Toast.LENGTH_SHORT).show(); 
   return; 
  } 
  // 顯示進(jìn)度條 
  mProgressDialog = ProgressDialog.show(this, null, "正在加載..."); 
 
  new Thread(new Runnable() 
  { 
 
   @Override 
   public void run() 
   { 
    Uri mImageUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI; 
    ContentResolver mContentResolver = MainActivity.this 
      .getContentResolver(); 
 
    // 只查詢jpeg和png的圖片 
    Cursor mCursor = mContentResolver.query(mImageUri, null, 
      MediaStore.Images.Media.MIME_TYPE + "=? or " 
        + MediaStore.Images.Media.MIME_TYPE + "=?", 
      new String[] { "image/jpeg", "image/png" }, 
      MediaStore.Images.Media.DATE_MODIFIED); 
 
    while (mCursor.moveToNext()) 
    { 
     // 獲取圖片的路徑 
     String path = mCursor.getString(mCursor 
       .getColumnIndex(MediaStore.Images.Media.DATA)); 
     // 獲取該圖片的父路徑名 
     File parentFile = new File(path).getParentFile(); 
     String dirPath = parentFile.getAbsolutePath(); 
      
     //利用一個(gè)HashSet防止多次掃描同一個(gè)文件夾（不加這個(gè)判斷，圖片多起來還是相當(dāng)恐怖的~~） 
     if(mDirPaths.contains(dirPath)) 
     { 
      continue; 
     } 
     else 
     { 
      mDirPaths.add(dirPath); 
     } 
      
     int picSize = parentFile.list(new FilenameFilter() 
     { 
      @Override 
      public boolean accept(File dir, String filename) 
      { 
       if (filename.endsWith(".jpg")) 
        return true; 
       return false; 
      } 
     }).length; 
     if (picSize > mPicsSize) 
     { 
      mPicsSize = picSize; 
      mImgDir = parentFile; 
     } 
    } 
    mCursor.close(); 
    //掃描完成，輔助的HashSet也就可以釋放內(nèi)存了 
    mDirPaths = null ; 
    // 通知Handler掃描圖片完成 
    mHandler.sendEmptyMessage(0x110); 
 
   } 
  }).start(); 
 
 } 
}

MainActivity也是比較簡單的，使用ContentProvider輔助，找到圖片最多的文件夾后，直接handler去隱藏ProgressDialog，然后初始化數(shù)據(jù)，適配器等；
但是稍微注意一下：
（1）在掃描圖片時(shí)，使用了一個(gè)臨時(shí)的HashSet保存掃描過的文件夾，這樣可以有效的避免重復(fù)掃描。比如，我手機(jī)中有個(gè)文件夾下面有3000多張圖片，如果不判斷則會(huì)掃描這個(gè)文件夾3000多次，處理器時(shí)間以及內(nèi)存的消耗還是很可觀的。
（2）在適配器中，保存List<String>的時(shí)候，考慮只保存圖片的名稱，路徑單獨(dú)作為變量傳入。一般情況下，圖片的路徑比圖片名長很多，加入有3000張圖片，路徑長度30，圖片平均長度10，則List<String>保存完成路徑需要長度為：（30+10）*3000 = 120000 ; 而單獨(dú)存儲(chǔ)只需要：30+10*3000 = 30030 ；圖片越多，節(jié)省的內(nèi)存越客觀；
總之，盡可能的去減少內(nèi)存的消耗，這些都是很容易做到的~

3、GridView的適配器

package com.example.zhy_handler_imageloader; 
 
import java.util.List; 
 
import android.content.Context; 
import android.view.LayoutInflater; 
import android.view.View; 
import android.view.ViewGroup; 
import android.widget.BaseAdapter; 
import android.widget.ImageView; 
 
import com.zhy.utils.ImageLoader; 
 
public class MyAdapter extends BaseAdapter 
{ 
 
 private Context mContext; 
 private List<String> mData; 
 private String mDirPath; 
 private LayoutInflater mInflater; 
 private ImageLoader mImageLoader; 
 
 public MyAdapter(Context context, List<String> mData, String dirPath) 
 { 
  this.mContext = context; 
  this.mData = mData; 
  this.mDirPath = dirPath; 
  mInflater = LayoutInflater.from(mContext); 
 
  mImageLoader = ImageLoader.getInstance(); 
 } 
 
 @Override 
 public int getCount() 
 { 
  return mData.size(); 
 } 
 
 @Override 
 public Object getItem(int position) 
 { 
  return mData.get(position); 
 } 
 
 @Override 
 public long getItemId(int position) 
 { 
  return position; 
 } 
 
 @Override 
 public View getView(int position, View convertView, final ViewGroup parent) 
 { 
  ViewHolder holder = null; 
  if (convertView == null) 
  { 
   holder = new ViewHolder(); 
   convertView = mInflater.inflate(R.layout.grid_item, parent, 
     false); 
   holder.mImageView = (ImageView) convertView 
     .findViewById(R.id.id_item_image); 
   convertView.setTag(holder); 
  } else 
  { 
   holder = (ViewHolder) convertView.getTag(); 
  } 
  holder.mImageView 
    .setImageResource(R.drawable.friends_sends_pictures_no); 
  //使用Imageloader去加載圖片 
  mImageLoader.loadImage(mDirPath + "/" + mData.get(position), 
    holder.mImageView); 
  return convertView; 
 } 
 
 private final class ViewHolder 
 { 
  ImageView mImageView; 
 } 
 
}

可以看到與傳統(tǒng)的適配器的寫法基本沒有什么不同之處，甚至在getView里面都沒有出現(xiàn)常見的回調(diào)（findViewByTag~用于防止圖片的錯(cuò)位）；僅僅多了一行代碼：

mImageLoader.loadImage(mDirPath + "/" + mData.get(position),holder.mImageView);

是不是用起來還是相當(dāng)爽的，所有需要處理的細(xì)節(jié)都被封裝了。

4、ImageLoader
現(xiàn)在才到了關(guān)鍵的時(shí)刻，我們封裝的ImageLoader類，當(dāng)然我們的異步消息處理機(jī)制也出現(xiàn)在其中。
首先是一個(gè)懶加載的單例

/** 
  * 單例獲得該實(shí)例對(duì)象 
  * 
  * @return 
  */ 
 public static ImageLoader getInstance() 
 { 
 
  if (mInstance == null) 
  { 
   synchronized (ImageLoader.class) 
   { 
    if (mInstance == null) 
    { 
     mInstance = new ImageLoader(1, Type.LIFO); 
    } 
   } 
  } 
  return mInstance; 
 }

沒啥說的，直接調(diào)用私有的構(gòu)造方法，可以看到，默認(rèn)傳入了1（線程池中線程的數(shù)量），和LIFO（隊(duì)列的工作方式）

private ImageLoader(int threadCount, Type type) 
 { 
  init(threadCount, type); 
 } 
 
 private void init(int threadCount, Type type) 
 { 
  // loop thread 
  mPoolThread = new Thread() 
  { 
   @Override 
   public void run() 
   { 
    try 
    { 
     // 請求一個(gè)信號(hào)量 
     mSemaphore.acquire(); 
    } catch (InterruptedException e) 
    { 
    } 
    Looper.prepare(); 
 
    mPoolThreadHander = new Handler() 
    { 
     @Override 
     public void handleMessage(Message msg) 
     { 
      mThreadPool.execute(getTask()); 
      try 
      { 
       mPoolSemaphore.acquire(); 
      } catch (InterruptedException e) 
      { 
      } 
     } 
    }; 
    // 釋放一個(gè)信號(hào)量 
    mSemaphore.release(); 
    Looper.loop(); 
   } 
  }; 
  mPoolThread.start(); 
 
  // 獲取應(yīng)用程序最大可用內(nèi)存 
  int maxMemory = (int) Runtime.getRuntime().maxMemory(); 
  int cacheSize = maxMemory / 8; 
  mLruCache = new LruCache<String, Bitmap>(cacheSize) 
  { 
   @Override 
   protected int sizeOf(String key, Bitmap value) 
   { 
    return value.getRowBytes() * value.getHeight(); 
   }; 
  }; 
 
  mThreadPool = Executors.newFixedThreadPool(threadCount); 
  mPoolSemaphore = new Semaphore(threadCount); 
  mTasks = new LinkedList<Runnable>(); 
  mType = type == null ? Type.LIFO : type; 
 
 }

然后在私有構(gòu)造里面調(diào)用了我們的init方法，在這個(gè)方法的開始就創(chuàng)建了mPoolThread這個(gè)子線程，在這個(gè)子線程中我們執(zhí)行了Looper.prepare,初始化mPoolThreadHander，Looper.loop；如果看過上篇博客，一定知道，此時(shí)在這個(gè)子線程中維護(hù)了一個(gè)消息隊(duì)列，且這個(gè)子線程會(huì)進(jìn)入一個(gè)無限讀取消息的循環(huán)中，而mPoolThreadHander這個(gè)handler發(fā)送的消息會(huì)直接發(fā)送至此線程中的消息隊(duì)列。然后看mPoolThreadHander中handleMessage的方法，直接調(diào)用了getTask方法取出一個(gè)任務(wù)，然后放入線程池去執(zhí)行。如果你比較細(xì)心，可能會(huì)發(fā)現(xiàn)里面還有一些信號(hào)量的操作的代碼。簡單說一下mSemaphore（信號(hào)數(shù)為1）的作用，由于mPoolThreadHander實(shí)在子線程初始化的，所以我在初始化前調(diào)用了mSemaphore.acquire去請求一個(gè)信號(hào)量，然后在初始化完成后釋放了此信號(hào)量，我為什么這么做呢？因?yàn)樵谥骶€程可能會(huì)立即使用到mPoolThreadHander，但是mPoolThreadHander是在子線程初始化的，雖然速度很快，但是我也不能百分百的保證，主線程使用時(shí)已經(jīng)初始化結(jié)束，為了避免空指針異常，所以我在主線程需要使用的時(shí)候，是這么調(diào)用的：

/** 
  * 添加一個(gè)任務(wù) 
  * 
  * @param runnable 
  */ 
 private synchronized void addTask(Runnable runnable) 
 { 
  try 
  { 
   // 請求信號(hào)量，防止mPoolThreadHander為null 
   if (mPoolThreadHander == null) 
    mSemaphore.acquire(); 
  } catch (InterruptedException e) 
  { 
  } 
  mTasks.add(runnable); 
  mPoolThreadHander.sendEmptyMessage(0x110); 
 }

如果mPoolThreadHander沒有初始化完成，則會(huì)去acquire一個(gè)信號(hào)量，其實(shí)就是去等待mPoolThreadHander初始化完成。如果對(duì)此感興趣的，可以將關(guān)于mSemaphore的代碼注釋，然后在初始化mPoolThreadHander使用Thread.sleep去暫停1秒，就會(huì)發(fā)現(xiàn)這樣的錯(cuò)誤。
初始化結(jié)束，就會(huì)在getView中調(diào)用

mImageLoader.loadImage(mDirPath + "/" + mData.get(position),holder.mImageView);

方法了，所以我們?nèi)タ磍oadImage方法吧

/** 
  * 加載圖片 
  * 
  * @param path 
  * @param imageView 
  */ 
 public void loadImage(final String path, final ImageView imageView) 
 { 
  // set tag 
  imageView.setTag(path); 
  // UI線程 
  if (mHandler == null) 
  { 
   mHandler = new Handler() 
   { 
    @Override 
    public void handleMessage(Message msg) 
    { 
     ImgBeanHolder holder = (ImgBeanHolder) msg.obj; 
     ImageView imageView = holder.imageView; 
     Bitmap bm = holder.bitmap; 
     String path = holder.path; 
     if (imageView.getTag().toString().equals(path)) 
     { 
      imageView.setImageBitmap(bm); 
     } 
    } 
   }; 
  } 
 
  Bitmap bm = getBitmapFromLruCache(path); 
  if (bm != null) 
  { 
   ImgBeanHolder holder = new ImgBeanHolder(); 
   holder.bitmap = bm; 
   holder.imageView = imageView; 
   holder.path = path; 
   Message message = Message.obtain(); 
   message.obj = holder; 
   mHandler.sendMessage(message); 
  } else 
  { 
   addTask(new Runnable() 
   { 
    @Override 
    public void run() 
    { 
 
     ImageSize imageSize = getImageViewWidth(imageView); 
 
     int reqWidth = imageSize.width; 
     int reqHeight = imageSize.height; 
 
     Bitmap bm = decodeSampledBitmapFromResource(path, reqWidth, 
       reqHeight); 
     addBitmapToLruCache(path, bm); 
     ImgBeanHolder holder = new ImgBeanHolder(); 
     holder.bitmap = getBitmapFromLruCache(path); 
     holder.imageView = imageView; 
     holder.path = path; 
     Message message = Message.obtain(); 
     message.obj = holder; 
     // Log.e("TAG", "mHandler.sendMessage(message);"); 
     mHandler.sendMessage(message); 
     mPoolSemaphore.release(); 
    } 
   }); 
  } 
 
 }

這段代碼比較長，當(dāng)然也是比較核心的代碼了
10-29行：首先將傳入imageView設(shè)置了path，然在初始化了一個(gè)mHandler用于設(shè)置imageView的bitmap，注意此時(shí)在UI線程，也就是這個(gè)mHandler發(fā)出的消息，會(huì)在UI線程中調(diào)用。可以看到在handleMessage中，我們從消息中取出ImageView，bitmap，path；然后將path與imageView的tag進(jìn)行比較，防止圖片的錯(cuò)位，最后設(shè)置bitmap;
31行：我們首先去從LruCache中去查找是否已經(jīng)緩存了此圖片
32-40：如果找到了，則直接使用mHandler去發(fā)送消息，這里使用了一個(gè)ImgBeanHolder去封裝了ImageView，Bitmap，Path這三個(gè)對(duì)象。然后更新執(zhí)行handleMessage代碼去更新UI
43-66行：如果沒有存在緩存中，則創(chuàng)建一個(gè)Runnable對(duì)象作為任務(wù)，去執(zhí)行addTask方法加入任務(wù)隊(duì)列
49行：getImageViewWidth根據(jù)ImageView獲取適當(dāng)?shù)膱D片的尺寸，用于后面的壓縮圖片，代碼按順序貼下下面
54行：會(huì)根據(jù)計(jì)算的需要的寬和高，對(duì)圖片進(jìn)行壓縮。代碼按順序貼下下面
56行：將壓縮后的圖片放入緩存
58-64行，創(chuàng)建消息，使用mHandler進(jìn)行發(fā)送，更新UI

/** 
  * 根據(jù)ImageView獲得適當(dāng)?shù)膲嚎s的寬和高 
  * 
  * @param imageView 
  * @return 
  */ 
 private ImageSize getImageViewWidth(ImageView imageView) 
 { 
  ImageSize imageSize = new ImageSize(); 
  final DisplayMetrics displayMetrics = imageView.getContext() 
    .getResources().getDisplayMetrics(); 
  final LayoutParams params = imageView.getLayoutParams(); 
 
  int width = params.width == LayoutParams.WRAP_CONTENT ? 0 : imageView 
    .getWidth(); // Get actual image width 
  if (width <= 0) 
   width = params.width; // Get layout width parameter 
  if (width <= 0) 
   width = getImageViewFieldValue(imageView, "mMaxWidth"); // Check 
                 // maxWidth 
                 // parameter 
  if (width <= 0) 
   width = displayMetrics.widthPixels; 
  int height = params.height == LayoutParams.WRAP_CONTENT ? 0 : imageView 
    .getHeight(); // Get actual image height 
  if (height <= 0) 
   height = params.height; // Get layout height parameter 
  if (height <= 0) 
   height = getImageViewFieldValue(imageView, "mMaxHeight"); // Check 
                  // maxHeight 
                  // parameter 
  if (height <= 0) 
   height = displayMetrics.heightPixels; 
  imageSize.width = width; 
  imageSize.height = height; 
  return imageSize; 
 
 } 

/** 
  * 根據(jù)計(jì)算的inSampleSize，得到壓縮后圖片 
  * 
  * @param pathName 
  * @param reqWidth 
  * @param reqHeight 
  * @return 
  */ 
 private Bitmap decodeSampledBitmapFromResource(String pathName, 
   int reqWidth, int reqHeight) 
 { 
  // 第一次解析將inJustDecodeBounds設(shè)置為true，來獲取圖片大小 
  final BitmapFactory.Options options = new BitmapFactory.Options(); 
  options.inJustDecodeBounds = true; 
  BitmapFactory.decodeFile(pathName, options); 
  // 調(diào)用上面定義的方法計(jì)算inSampleSize值 
  options.inSampleSize = calculateInSampleSize(options, reqWidth, 
    reqHeight); 
  // 使用獲取到的inSampleSize值再次解析圖片 
  options.inJustDecodeBounds = false; 
  Bitmap bitmap = BitmapFactory.decodeFile(pathName, options); 
 
  return bitmap; 
 }

接下來看AddTask的代碼：

/** 
  * 添加一個(gè)任務(wù) 
  * 
  * @param runnable 
  */ 
 private synchronized void addTask(Runnable runnable) 
 { 
  try 
  { 
   // 請求信號(hào)量，防止mPoolThreadHander為null 
   if (mPoolThreadHander == null) 
    mSemaphore.acquire(); 
  } catch (InterruptedException e) 
  { 
  } 
  mTasks.add(runnable); 
  mPoolThreadHander.sendEmptyMessage(0x110); 
 }

可以看到，簡單把任務(wù)放入任務(wù)隊(duì)列，然后使用mPoolThreadHander發(fā)送一個(gè)消息到后臺(tái)的loop中，后臺(tái)的loop會(huì)取出消息執(zhí)行：

mThreadPool.execute(getTask());

execute執(zhí)行的就是上面分析的Runnable中的run方法了。
注意一下：上述代碼中還會(huì)看到mPoolSemaphore這個(gè)信號(hào)量的身影，說下用處；因?yàn)檎{(diào)用addTask之后，會(huì)直接去從任務(wù)隊(duì)列取出一個(gè)任務(wù)，放入線程池，由于線程池內(nèi)部其實(shí)也維持著一個(gè)隊(duì)列，那么”從任務(wù)隊(duì)列取出一個(gè)任務(wù)”這個(gè)動(dòng)作會(huì)瞬間完成，直接加入線程池維護(hù)的隊(duì)列中；這樣會(huì)造成比如用戶設(shè)置了調(diào)度隊(duì)列為LIFO，但是由于”從任務(wù)隊(duì)列取出一個(gè)任務(wù)”這個(gè)動(dòng)作會(huì)瞬間完成，隊(duì)列中始終維持在空隊(duì)列的狀態(tài)，所以讓用戶感覺LIFO根本沒有效果；所以我按照用戶設(shè)置線程池工作線程的數(shù)量設(shè)置了一個(gè)信號(hào)量，這樣在保證任務(wù)執(zhí)行完后，才會(huì)從任務(wù)隊(duì)列去取任務(wù)，使得LIFO有著很好的效果；有興趣的可以注釋了所有的mPoolSemaphore代碼，測試下就明白了。
到此代碼基本介紹完畢。細(xì)節(jié)還是很多的，后面會(huì)附上源碼，有興趣的研究下代碼，沒有興趣的，可以運(yùn)行下代碼，如果感覺流暢性不錯(cuò)，體驗(yàn)不錯(cuò)，可以作為工具類直接使用，使用也就getView里面一行代碼。

貼一下效果圖，我手機(jī)最多的文件夾大概3000張圖片，加載速度還是相當(dāng)相當(dāng)流暢的：

真機(jī)錄的，有點(diǎn)丟幀，注意看效果圖，中間我瘋狂拖動(dòng)滾動(dòng)條，但是圖片基本還是瞬間顯示的。
說一下，F(xiàn)IFO如果設(shè)置為這個(gè)模式，在控件中不做處理的話，用戶拉的比較慢效果還是不錯(cuò)的，但是用戶手機(jī)如果有個(gè)幾千張，瞬間拉到最后，最后一屏圖片的顯示可能需要喝杯茶了~當(dāng)然了，大家可以在控件中做處理，要么，拖動(dòng)的時(shí)候不去加載圖片，停在來再加載?；蛘?，當(dāng)手機(jī)抬起，給了一個(gè)很大的加速度，屏幕還是很快的滑動(dòng)時(shí)停止加載，停下時(shí)加載圖片。
LIFO這個(gè)模式可能用戶體驗(yàn)會(huì)好很多，不管用戶拉多塊，最終停下來的那一屏圖片都會(huì)瞬間顯示~
最后掰一掰使用異步消息處理機(jī)制作為背后的子線程的好處，其實(shí)直接用一個(gè)子線程也可以實(shí)現(xiàn)，但是，這個(gè)子線程run中可能需要while(true）然后每隔200毫秒甚至更短的時(shí)間去查詢?nèi)蝿?wù)隊(duì)列是否有任務(wù)，沒有則Thread.sleep，然后再去查詢；這樣如果長時(shí)間沒有去添加任務(wù)，這個(gè)線程依然會(huì)不斷的去查詢；
而異步消息機(jī)制，只有在發(fā)送消息時(shí)才會(huì)去執(zhí)行，當(dāng)然更準(zhǔn)確；當(dāng)長時(shí)間沒有任務(wù)到達(dá)時(shí)，也不會(huì)去查詢，會(huì)一直阻塞在這；還有一點(diǎn)，這個(gè)機(jī)制Android內(nèi)部實(shí)現(xiàn)的，怎么也比我們搞個(gè)Thread穩(wěn)定性、效率高吧~

您可能感興趣的文章: