欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  移动技术

Android App中实现图片异步加载的实例分享

程序员文章站 2024-02-28 14:00:34
一、概述 一般大量图片的加载,比如gridview实现手机的相册功能,一般会用到lrucache,线程池,任务队列等;那么异步消息处理可以用哪呢? 1、用于ui线程当b...

一、概述
一般大量图片的加载,比如gridview实现手机的相册功能,一般会用到lrucache,线程池,任务队列等;那么异步消息处理可以用哪呢?
1、用于ui线程当bitmap加载完成后更新imageview
2、在图片加载类初始化时,我们会在一个子线程中维护一个loop实例,当然子线程中也就有了messagequeue,looper会一直在那loop停着等待消息的到达,当有消息到达时,从任务队列按照队列调度的方式(fifo,lifo等),取出一个任务放入线程池中进行处理。
简易的一个流程:当需要加载一张图片,首先把加载图片加入任务队列,然后使用loop线程(子线程)中的hander发送一个消息,提示有任务到达,loop()(子线程)中会接着取出一个任务,去加载图片,当图片加载完成,会使用ui线程的handler发送一个消息去更新ui界面。
说了这么多,大家估计也觉得云里来雾里去的,下面看实际的例子。

二、图库功能的实现
该程序首先扫描手机中所有包含图片的文件夹,最终选择图片最多的文件夹,使用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> 

布局文件相当简单就一个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; 
  
 /** 
  * 存储文件夹中的图片数量 
  */ 
 private int mpicssize; 
 /** 
  * 图片数量最多的文件夹 
  */ 
 private file mimgdir; 
 /** 
  * 所有的图片 
  */ 
 private list<string> mimgs; 
 
 private gridview mgirdview; 
 private listadapter madapter; 
 /** 
  * 临时的辅助类,用于防止同一个文件夹的多次扫描 
  */ 
 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; 
    } 
   })); 
   /** 
    * 可以看到文件夹的路径和图片的路径分开保存,极大的减少了内存的消耗; 
    */ 
   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扫描手机中的图片,此方法在运行在子线程中 完成图片的扫描,最终获得jpg最多的那个文件夹 
  */ 
 private void getimages() 
 { 
  if (!environment.getexternalstoragestate().equals( 
    environment.media_mounted)) 
  { 
   toast.maketext(this, "暂无外部存储", toast.length_short).show(); 
   return; 
  } 
  // 显示进度条 
  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(); 
      
     //利用一个hashset防止多次扫描同一个文件夹(不加这个判断,图片多起来还是相当恐怖的~~) 
     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也就可以释放内存了 
    mdirpaths = null ; 
    // 通知handler扫描图片完成 
    mhandler.sendemptymessage(0x110); 
 
   } 
  }).start(); 
 
 } 
} 

mainactivity也是比较简单的,使用contentprovider辅助,找到图片最多的文件夹后,直接handler去隐藏progressdialog,然后初始化数据,适配器等;
但是稍微注意一下:
(1)在扫描图片时,使用了一个临时的hashset保存扫描过的文件夹,这样可以有效的避免重复扫描。比如,我手机中有个文件夹下面有3000多张图片,如果不判断则会扫描这个文件夹3000多次,处理器时间以及内存的消耗还是很可观的。
(2)在适配器中,保存list<string>的时候,考虑只保存图片的名称,路径单独作为变量传入。一般情况下,图片的路径比图片名长很多,加入有3000张图片,路径长度30,图片平均长度10,则list<string>保存完成路径需要长度为:(30+10)*3000 = 120000 ; 而单独存储只需要:30+10*3000 = 30030 ; 图片越多,节省的内存越客观;
总之,尽可能的去减少内存的消耗,这些都是很容易做到的~

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; 
 } 
 
} 

可以看到与传统的适配器的写法基本没有什么不同之处,甚至在getview里面都没有出现常见的回调(findviewbytag~用于防止图片的错位);仅仅多了一行代码:

mimageloader.loadimage(mdirpath + "/" + mdata.get(position),holder.mimageview);

是不是用起来还是相当爽的,所有需要处理的细节都被封装了。

4、imageloader
现在才到了关键的时刻,我们封装的imageloader类,当然我们的异步消息处理机制也出现在其中。
首先是一个懒加载的单例

/** 
  * 单例获得该实例对象 
  * 
  * @return 
  */ 
 public static imageloader getinstance() 
 { 
 
  if (minstance == null) 
  { 
   synchronized (imageloader.class) 
   { 
    if (minstance == null) 
    { 
     minstance = new imageloader(1, type.lifo); 
    } 
   } 
  } 
  return minstance; 
 } 

没啥说的,直接调用私有的构造方法,可以看到,默认传入了1(线程池中线程的数量),和lifo(队列的工作方式)

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 
    { 
     // 请求一个信号量 
     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) 
      { 
      } 
     } 
    }; 
    // 释放一个信号量 
    msemaphore.release(); 
    looper.loop(); 
   } 
  }; 
  mpoolthread.start(); 
 
  // 获取应用程序最大可用内存 
  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; 
 
 } 

然后在私有构造里面调用了我们的init方法,在这个方法的开始就创建了mpoolthread这个子线程,在这个子线程中我们执行了looper.prepare,初始化mpoolthreadhander,looper.loop;如果看过上篇博客,一定知道,此时在这个子线程中维护了一个消息队列,且这个子线程会进入一个无限读取消息的循环中,而mpoolthreadhander这个handler发送的消息会直接发送至此线程中的消息队列。然后看mpoolthreadhander中handlemessage的方法,直接调用了gettask方法取出一个任务,然后放入线程池去执行。如果你比较细心,可能会发现里面还有一些信号量的操作的代码 。 简单说一下msemaphore(信号数为1)的作用,由于mpoolthreadhander实在子线程初始化的,所以我在初始化前调用了msemaphore.acquire去请求一个信号量,然后在初始化完成后释放了此信号量,我为什么这么做呢?因为在主线程可能会立即使用到mpoolthreadhander,但是mpoolthreadhander是在子线程初始化的,虽然速度很快,但是我也不能百分百的保证,主线程使用时已经初始化结束,为了避免空指针异常,所以我在主线程需要使用的时候,是这么调用的:

/** 
  * 添加一个任务 
  * 
  * @param runnable 
  */ 
 private synchronized void addtask(runnable runnable) 
 { 
  try 
  { 
   // 请求信号量,防止mpoolthreadhander为null 
   if (mpoolthreadhander == null) 
    msemaphore.acquire(); 
  } catch (interruptedexception e) 
  { 
  } 
  mtasks.add(runnable); 
  mpoolthreadhander.sendemptymessage(0x110); 
 } 

如果mpoolthreadhander没有初始化完成,则会去acquire一个信号量,其实就是去等待mpoolthreadhander初始化完成。如果对此感兴趣的,可以将关于msemaphore的代码注释,然后在初始化mpoolthreadhander使用thread.sleep去暂停1秒,就会发现这样的错误。
初始化结束,就会在getview中调用

mimageloader.loadimage(mdirpath + "/" + mdata.get(position),holder.mimageview);

方法了,所以我们去看loadimage方法吧

/** 
  * 加载图片 
  * 
  * @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(); 
    } 
   }); 
  } 
 
 } 

这段代码比较长,当然也是比较核心的代码了
10-29行:首先将传入imageview设置了path,然在初始化了一个mhandler用于设置imageview的bitmap,注意此时在ui线程,也就是这个mhandler发出的消息,会在ui线程中调用。可以看到在handlemessage中,我们从消息中取出imageview,bitmap,path;然后将path与imageview的tag进行比较,防止图片的错位,最后设置bitmap;
31行:我们首先去从lrucache中去查找是否已经缓存了此图片
32-40:如果找到了,则直接使用mhandler去发送消息,这里使用了一个imgbeanholder去封装了imageview,bitmap,path这三个对象。然后更新执行handlemessage代码去更新ui
43-66行:如果没有存在缓存中,则创建一个runnable对象作为任务,去执行addtask方法加入任务队列
49行:getimageviewwidth根据imageview获取适当的图片的尺寸,用于后面的压缩图片,代码按顺序贴下下面
54行:会根据计算的需要的宽和高,对图片进行压缩。代码按顺序贴下下面
56行:将压缩后的图片放入缓存
58-64行,创建消息,使用mhandler进行发送,更新ui

/** 
  * 根据imageview获得适当的压缩的宽和高 
  * 
  * @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; 
 
 } 

/** 
  * 根据计算的insamplesize,得到压缩后图片 
  * 
  * @param pathname 
  * @param reqwidth 
  * @param reqheight 
  * @return 
  */ 
 private bitmap decodesampledbitmapfromresource(string pathname, 
   int reqwidth, int reqheight) 
 { 
  // 第一次解析将injustdecodebounds设置为true,来获取图片大小 
  final bitmapfactory.options options = new bitmapfactory.options(); 
  options.injustdecodebounds = true; 
  bitmapfactory.decodefile(pathname, options); 
  // 调用上面定义的方法计算insamplesize值 
  options.insamplesize = calculateinsamplesize(options, reqwidth, 
    reqheight); 
  // 使用获取到的insamplesize值再次解析图片 
  options.injustdecodebounds = false; 
  bitmap bitmap = bitmapfactory.decodefile(pathname, options); 
 
  return bitmap; 
 } 

接下来看addtask的代码:

/** 
  * 添加一个任务 
  * 
  * @param runnable 
  */ 
 private synchronized void addtask(runnable runnable) 
 { 
  try 
  { 
   // 请求信号量,防止mpoolthreadhander为null 
   if (mpoolthreadhander == null) 
    msemaphore.acquire(); 
  } catch (interruptedexception e) 
  { 
  } 
  mtasks.add(runnable); 
  mpoolthreadhander.sendemptymessage(0x110); 
 } 

可以看到,简单把任务放入任务队列,然后使用mpoolthreadhander发送一个消息到后台的loop中,后台的loop会取出消息执行:

mthreadpool.execute(gettask());

execute执行的就是上面分析的runnable中的run方法了。
注意一下:上述代码中还会看到mpoolsemaphore这个信号量的身影,说下用处;因为调用addtask之后,会直接去从任务队列取出一个任务,放入线程池,由于线程池内部其实也维持着一个队列,那么”从任务队列取出一个任务”这个动作会瞬间完成,直接加入线程池维护的队列中;这样会造成比如用户设置了调度队列为lifo,但是由于”从任务队列取出一个任务”这个动作会瞬间完成,队列中始终维持在空队列的状态,所以让用户感觉lifo根本没有效果;所以我按照用户设置线程池工作线程的数量设置了一个信号量,这样在保证任务执行完后,才会从任务队列去取任务,使得lifo有着很好的效果;有兴趣的可以注释了所有的mpoolsemaphore代码,测试下就明白了。
到此代码基本介绍完毕。细节还是很多的,后面会附上源码,有兴趣的研究下代码,没有兴趣的,可以运行下代码,如果感觉流畅性不错,体验不错,可以作为工具类直接使用,使用也就getview里面一行代码。

贴一下效果图,我手机最多的文件夹大概3000张图片,加载速度还是相当相当流畅的:

Android App中实现图片异步加载的实例分享

真机录的,有点丢帧,注意看效果图,中间我疯狂拖动滚动条,但是图片基本还是瞬间显示的。
说一下,fifo如果设置为这个模式,在控件中不做处理的话,用户拉的比较慢效果还是不错的,但是用户手机如果有个几千张,瞬间拉到最后,最后一屏图片的显示可能需要喝杯茶了~当然了,大家可以在控件中做处理,要么,拖动的时候不去加载图片,停在来再加载。或者,当手机抬起,给了一个很大的加速度,屏幕还是很快的滑动时停止加载,停下时加载图片。
lifo这个模式可能用户体验会好很多,不管用户拉多块,最终停下来的那一屏图片都会瞬间显示~
最后掰一掰使用异步消息处理机制作为背后的子线程的好处,其实直接用一个子线程也可以实现,但是,这个子线程run中可能需要while(true)然后每隔200毫秒甚至更短的时间去查询任务队列是否有任务,没有则thread.sleep,然后再去查询;这样如果长时间没有去添加任务,这个线程依然会不断的去查询;
而异步消息机制,只有在发送消息时才会去执行,当然更准确;当长时间没有任务到达时,也不会去查询,会一直阻塞在这;还有一点,这个机制android内部实现的,怎么也比我们搞个thread稳定性、效率高吧~