android 加载图片轻松避免OOM(out of memory) 支持设置缓存大小,不再强制catch OOM

转载自：http://blog.csdn.net/liaoxingliao/article/details/7168500

package l.test1.util;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.BitmapFactory.Options;

public class BitmapUtil {

private static final Size ZERO_SIZE = new Size(0,0);

private static final Options OPTIONS_GET_SIZE = new Options();

private static final Options OPTIONS_DECODE = new Options();

static{

OPTIONS_GET_SIZE.inJustDecodeBounds = true;

}

public static Size getBitMapSize(String path){

File file = new File(path);

if(file.exists()){

InputStream in = null;

try{

in = new FileInputStream(file);

BitmapFactory.decodeStream(in, null, OPTIONS_GET_SIZE);

return new Size(OPTIONS_GET_SIZE.outWidth,OPTIONS_GET_SIZE.outHeight);

} catch (FileNotFoundException e) {

return ZERO_SIZE;

}finally{

closeInputStream(in);

}

}

return ZERO_SIZE;

}

public static Bitmap createBitmap(String path,int width,int height){

File file = new File(path);

if(file.exists()){

InputStream in = null;

try {

in = new FileInputStream(file);

Size size = getBitMapSize(path);

if(size.equals(ZERO_SIZE)){

return null;

}

int scale = 1;

int a = size.getWidth() / width;

int b = size.getHeight() / height;

scale = Math.max(a, b);

synchronized (OPTIONS_DECODE) {

OPTIONS_DECODE.inSampleSize = scale;

Bitmap bitMap = BitmapFactory.decodeStream(in,null,OPTIONS_DECODE);

return bitMap;

}

} catch (FileNotFoundException e) {

e.printStackTrace();

}

finally{

closeInputStream(in);

}

}

return null;

}

public static void destory(Bitmap bitmap){

if(null != bitmap && !bitmap.isRecycled()){

bitmap.recycle();

bitmap = null;

}

}

private static void closeInputStream(InputStream in) {

if(null != in){

try {

in.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

class Size{

private int width,height;

Size(int width,int height){

this.width = width;

this.height = height;

}

public int getWidth() {

return width;

}

public int getHeight() {

return height;

}

}

package l.test1.util;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.Map;

import java.util.Set;

import java.util.Stack;

import android.graphics.Bitmap;

/**

* Bitmap工具类,缓存用过的指定数量的图片,使用此工具类,不再需要手动管理Bitmap内存

* 原理:

* 用一个队列保存使用Bitmap的顺序,每次使用Bitmap将对象移动到队列头

* 当内存不够,或者达到制定的缓存数量的时候,回收队列尾部图片

* 保证当前使用最多的图片得到最长时间的缓存,提高速度

* @author liaoxingliao

*

*/

public final class BitMapLRU {

private static int CACHE_BYTE_SIZE = 10*1024*1024; //缓存10M图片

private static int CACHE_SIZE = 2000; //缓存图片数量

private static int byteSize = 0;

private static final byte[] LOCKED = new byte[0];

private static final LinkedList<String> CACHE_ENTRIES = //此对象用来保持Bitmap的回收顺序,保证最后使用的图片被回收

new LinkedList<String>(){

private static final long serialVersionUID = 1L;

@Override

public void addFirst(String object) {

while(remove(object));

super.addFirst(object);

}

};

private static final Stack<QueueEntry> TASK_QUEUE = new Stack<QueueEntry>(); //线程请求创建图片的队列

private static final Set<String> TASK_QUEUE_INDEX = new HashSet<String>(); //保存队列中正在处理的图片的key,有效防止重复添加到请求创建队列

private static final Map<String,Bitmap> IMG_CACHE_INDEX = new HashMap<String,Bitmap>(); //缓存Bitmap 通过图片路径,图片大小

static{

// 初始化创建图片线程,并等待处理

new Thread(){

{setDaemon(true);}

public void run() {

while(true) {

synchronized (TASK_QUEUE) {

if(TASK_QUEUE.isEmpty()) {

try {

TASK_QUEUE.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

QueueEntry entry = TASK_QUEUE.pop();

String key = createKey(entry.path,entry.width,entry.height);

TASK_QUEUE_INDEX.remove(key);

createBitmap(entry.path, entry.width, entry.height);

}

}

}.start();

}

/**

* 创建一张图片 如果缓存中已经存在,则返回缓存中的图,否则创建一个新的对象,并加入缓存

* 宽度,高度,为了缩放原图减少内存的,如果输入的宽,高,比原图大,返回原图

* @param path 图片物理路径 (必须是本地路径,不能是网络路径)

* @param width 需要的宽度

* @param height 需要的高度

* @return

*/

public static Bitmap createBitmap(String path, int width, int height) {

Bitmap bitMap = null;

try{

while(CACHE_ENTRIES.size() >= CACHE_SIZE || byteSize >= CACHE_BYTE_SIZE) {

destoryLast();

}

bitMap = useBitmap(path, width, height);

if( bitMap != null && !bitMap.isRecycled()){

return bitMap;//4294967296

}

bitMap = BitmapUtil.createBitmap(path, width, height);

if(bitMap == null) { //可能不是有效的图片..

return null;

}

byteSize += (bitMap.getRowBytes() * bitMap.getHeight());

String key = createKey(path,width,height);

synchronized (LOCKED) {

IMG_CACHE_INDEX.put(key, bitMap);

CACHE_ENTRIES.addFirst(key);

}

}catch(OutOfMemoryError err) {

System.out.println("OOM:" + byteSize);

destoryLast();

return createBitmap(path, width, height);

}

return bitMap;

}

/**

* 设置缓存图片数量 如果输入负数,会产生异常

* @param size

*/

public static void setCacheSize(int size) {

if(size <=0 ){

throw new RuntimeException("size :"+size);

}

while(size < CACHE_ENTRIES.size()){

destoryLast();

}

CACHE_SIZE = size;

}

/**

* 加入一个图片处理请求到图片创建队列

* @param path 图片路径(本地)

* @param width 图片宽度

* @param height 图片高度

*/

public static void addTask(String path, int width, int height) {

QueueEntry entry = new QueueEntry();

entry.path = path;

entry.width = width;

entry.height = height;

synchronized (TASK_QUEUE) {

while(TASK_QUEUE.size() > 20) {

QueueEntry e = TASK_QUEUE.lastElement();

TASK_QUEUE.remove(e);

TASK_QUEUE_INDEX.remove(createKey(e.path, e.width, e.height));

}

String key = createKey(path,width,height);

if(!TASK_QUEUE_INDEX.contains(key) && !IMG_CACHE_INDEX.containsKey(key)){

TASK_QUEUE.push(entry);

TASK_QUEUE_INDEX.add(key);

TASK_QUEUE.notify();

}

}

}

public static void cleanTask() {

synchronized (TASK_QUEUE) {

TASK_QUEUE_INDEX.clear();

TASK_QUEUE.clear();

}

}

// 将图片加入队列头

private static Bitmap useBitmap(String path,int width,int height) {

Bitmap bitMap = null;

String key = createKey(path,width,height);

synchronized (LOCKED) {

bitMap = IMG_CACHE_INDEX.get(key);

if(null != bitMap){

CACHE_ENTRIES.addFirst(key);

}

}

return bitMap;

}

// 回收最后一张图片

private static void destoryLast() {

synchronized (LOCKED) {

if(!CACHE_ENTRIES.isEmpty()) {

String key = CACHE_ENTRIES.removeLast();

if(key.length() > 0) {

Bitmap bitMap = IMG_CACHE_INDEX.remove(key);

if(bitMap != null) {

bitMap.recycle();

byteSize -= (bitMap.getRowBytes() * bitMap.getHeight());

bitMap = null;

}

}

}

}

}

// 创建键

private static String createKey(String path,int width,int height) {

if(null == path || path.length() == 0) {

return "";

}

return path+"_"+width+"_"+height;

}

// 队列缓存参数对象

static class QueueEntry{

public String path;

public int width;

public int height;

}

}