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