应用场景是这样的，在做一个项目的过程中，该项目用到了大量的图片（可以理解为就是用图片累计起来的，而且设计到大量的动画），而且是高清的那种，而且不能图片显示有丝毫瑕疵的地方，因为做出的app是在一台很大（47寸）的设备上显示，那么我们常用的处理方式：
1.把大图片事先经过压缩，比如200kb的一个图片，经过压缩为50kb的图片，这样是行不通的。
2.把大图片加载到内存中之后，进行压缩（使用位图Bitmap），这样也是行不通的。
诚然，上述方法是可以减少图片使用的内存的，但是无疑也会降低图片的质量，这是不允许的。
下面一段代码，我们来展示，我是如何解决这个问题，已从sd卡上加载图片为例：
下面的类，大家从
showImageAsyn方法开始看就好了，相信大家都看的懂。
/**
* 异步加载图片、缓存工具类
* @author
*
*/
public class AsyncBitmapCache {
static private AsyncBitmapCache cache;
/** 用于Chche内容的存�? */
private Hashtable<String, MySoftRef> hashRefs;
/** 垃圾Reference的队列（�?��用的对象已经被回收，则将该引用存入队列中�? */
private ReferenceQueue<Bitmap> q;
// 任务队列
private List<Task> taskQueue;
private boolean isRunning = false;
/**
* 构造方法
*/
private AsyncBitmapCache() {
hashRefs = new Hashtable<String, MySoftRef>();
q = new ReferenceQueue<Bitmap>();
//任务队列
taskQueue = new ArrayList<Task>();
// 启动图片下载线程
isRunning = true;
new Thread(runnable).start();
}
/**
* 取得缓存器实�?
*/
public static AsyncBitmapCache getInstance() {
if (cache == null) {
cache = new AsyncBitmapCache();
}
return cache;
}
private Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
// 子线程中返回的下载完成的任务
Task task = (Task)msg.obj;
// 调用callback对象的loadImage方法，并将图片路径和图片回传给adapter
task.callback.loadImage(task.path, task.bitmap);
}
};
/**
*
* @param imageView
* @param resId 图片加载完成前显示的图片资源ID
* @return
*/
private ImageCallback getImageCallback(final ImageView imageView){
return new ImageCallback() {
@Override
public void loadImage(String path, Bitmap bitmap) {
if(path.equals(imageView.getTag().toString())){
imageView.setImageBitmap(bitmap);
}
}
};
}
/**
*
* @param imageView
* @param resId 图片加载完成前显示的图片资源ID
* @return
*/
private ImageCallback getTextImageCallback(final TextImageView textImageView){
return new ImageCallback() {
@Override
public void loadImage(String path, Bitmap bitmap) {
if(path.equals(textImageView.getTag().toString())){
if(bitmap != null){
textImageView.setImageBitmap(bitmap);
}else{
textImageView.setTextViewText("加载图片失败...");
}
}
}
};
}
/**
*
* @param imageView 需要延迟加载图片的对象
* @param url 图片的URL地址
*/
public void showImageAsyn(ImageView imageView, String url){
imageView.setTag(url);
Bitmap bitmap = loadImageAsyn(url, getImageCallback(imageView));
if(bitmap != null){
imageView.setImageBitmap(bitmap);
}
}
/**
*
* @param imageView 需要延迟加载图片的对象
* @param url 图片的URL地址
*/
public void showTextImageAsyn(TextImageView textImageView, String url){
textImageView.setTag(url);
Bitmap bitmap = loadImageAsyn(url, getTextImageCallback(textImageView));
if(bitmap != null){
textImageView.setImageBitmap(bitmap);
}
}
private Bitmap loadImageAsyn(String path, ImageCallback callback){
Bitmap bmp = null;
// 缓存中是否有该Bitmap实例的软引用，如果有，从软引用中取得�?
// 如果没有软引用，或�?从软引用中得到的实例是null，重新构建一个实例，
// 并保存对这个新建实例的软引用
if (hashRefs.containsKey(path)) {
MySoftRef ref = (MySoftRef) hashRefs.get(path);
bmp = (Bitmap) ref.get();
}
if (bmp == null) {
// 如果缓存中不常在该图片，则创建图片下载任务
Task task = new Task();
task.path = path;
task.callback = callback;
if(!taskQueue.contains(task)){
taskQueue.add(task);
// 唤醒任务下载队列
synchronized (runnable) {
runnable.notify();
}
}
}
// 缓存中没有图片则返回null
return bmp;
}
private Runnable runnable = new Runnable() {
@Override
public void run() {
while(isRunning){
// 当队列中还有未处理的任务时，执行下载任务
while(taskQueue.size() > 0){
// 获取第一个任务，并将之从任务队列中删除
Task task = taskQueue.remove(0);
task.bitmap = BitmapFactory.decodeFile(task.path);
addCacheBitmap(task.bitmap, task.path);
if(handler != null){
// 创建消息对象，并将完成的任务添加到消息对象中
Message msg = handler.obtainMessage();
msg.obj = task;
// 发送消息回主线程
handler.sendMessage(msg);
}
}
//如果队列为空,则令线程等待
synchronized (this) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
};
/**
* 继承SoftReference，使得每�?��实例都具有可识别的标识�?
*/
private class MySoftRef extends SoftReference<Bitmap> {
private String _key = 0 + "";
public MySoftRef(Bitmap bmp, ReferenceQueue<Bitmap> q, String key) {
super(bmp, q);
_key = key;
}
}
/**
* 以软引用的方式对�?��Bitmap对象的实例进行引用并保存该引�?
*/
private void addCacheBitmap(Bitmap bmp, String key) {
cleanCache();// 清除垃圾引用
MySoftRef ref = new MySoftRef(bmp, q, key);
hashRefs.put(key, ref);
}
private void cleanCache() {
MySoftRef ref = null;
while ((ref = (MySoftRef) q.poll()) != null) {
hashRefs.remove(ref._key);
}
}
/**
* 清除Cache内的全部内容
*/
public void clearCache() {
cleanCache();
hashRefs.clear();
System.gc();
System.runFinalization();
}
}public class Task{
// 下载任务的下载路径
String path;
// 下载的图片
Bitmap bitmap;
// 回调对象
ImageCallback callback;
@Override
public boolean equals(Object o) {
Task task = (Task)o;
return task.path.equals(path);
}
}
其实，总结下来也就是两点：
1.使用异步的方式进行图片的加载。
2.使用软引用队列进行图片的缓存。
这样的好处是：
1.异步加载可以有效的减少主线程的负担，从而避免程序的卡顿。
2.使用软件引用来缓存图片，这样我们可以不用考虑图片的大小，因为当程序内存不够的时候，gc会去释放这些软引用占用的内存，而不会出现oom问题。
当然了，仅仅这样子还是不够的，还要进行下面几点：
1.你的图片不应该再使用xml来显示，即使你要展示那个图片是固定的，那么也要用上述的方式在代码中进行加载显示，而不应该直接使用android:src或者android:background等属性，因为这样两种方式，他们占的内存是一样的（经过测试，可信结果），但是软引用缓存的方式，是不会oom的，但是xml方式是会出现的。
2.对于显示的及时性，比如我们这个项目，是不能说想一般项目一样，切换页面之后显示加载，然后再显示，而是要求实时显示，那么就要求了加载速度了，这个方面大家可以参见我的另一篇博客，里面讲述了，我们的缓存机制，以及预加载，延迟加载等机制。
上述的措施，虽然能解决加载大量图片的oom的问题，但是有时候并不能解决卡顿的问题，原因很简单：
1.虽然耗时的读取图片的操作使用了异步，但是展示图片的操作还是主线程来做的。
2.对于展示大图片，比如200kb以上，那么如果主线程来做，那么会有很大的负担，还是会很卡。
下面，我们先看一个控件：
@SuppressLint("NewApi")
public class CustomTextureView extends TextureView implements TextureView.SurfaceTextureListener {
private Bitmap bitmap_bg;
public CustomTextureView(Context context) {
super(context);
this.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
init(context);
}
public CustomTextureView(Context context, AttributeSet attrs) {
super(context, attrs);
this.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
init(context);
}
public CustomTextureView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
this.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
init(context);
}
private void init(Context context) {
// bitmap_bg = BitmapCache.getInstance().getBitmap(R.drawable.navigation_bac, context);
}
public Bitmap getBitmap_bg() {
return bitmap_bg;
}
public void setBitmap_bg(Bitmap bitmap_bg) {
this.bitmap_bg = bitmap_bg;
}
@Override
public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
Canvas canvas = lockCanvas();
Paint paint = new Paint();
paint.setAntiAlias(true);
paint.setFilterBitmap(true);
RectF rectF = new RectF(0, 0, 1080, 1920);
canvas.drawBitmap(bitmap_bg, null, rectF, paint);
if (canvas != null) {
unlockCanvasAndPost(canvas);
}
}
@Override
public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
}
@Override
public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
return false;
}
@Override
public void onSurfaceTextureUpdated(SurfaceTexture surface) {
}
}使用方式也很简单：
<span style="white-space:pre"> </span>navBackGroundTextureView =(CustomTextureView) view.findViewById(R.id.navBackGroundTextureView);
navBackGroundTextureView.setBitmap_bg(BitmapCache.getInstance().getBitmap(navBackImgStr, mContext));
navBackGroundTextureView.setSurfaceTextureListener(navBackGroundTextureView);这样使用起来很简单，那么他可以有效解决展示大图片所造成的卡顿问题，因为它的作用就是另外起一个线程，来绘制所要展示的内容，那么就不会给主线程造成卡顿了，但是这个方式也不能滥用，因为线程过多也是很大的问题，其实我们还可以采用一些预加载，延时加载等之类的措施。
版权声明：本文为jiguangcanhen原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。