Android中加载网络资源时的优化可使用(线程+缓存)解决

概述网上关于这个方面的文章也不少，基本的思路是线程+缓存来解决。下面提出一些优化：1、采用线程池2、内存缓存+文件缓存3、内存缓存中网上很多是采用SoftReference来防止堆溢出，这儿严格限制只能使用最大JVM内存的1/4 网上关于这个方面的文章也不少，基本的思路是线程+缓存来解决。下面提出一些优化：
1、采用线程池
2、内存缓存+文件缓存
3、内存缓存中网上很多是采用SoftReference来防止堆溢出，这儿严格限制只能使用最大JVM内存的1/4
4、对下载的图片进行按比例缩放，以减少内存的消耗

具体的代码里面说明。先放上内存缓存类的代码MemoryCache.java：
复制代码 代码如下:
<SPAN ><STRONG>public class MemoryCache {
private static final String TAG = "MemoryCache";
// 放入缓存时是个同步 *** 作
// linkedHashMap构造方法的最后一个参数true代表这个map里的元素将按照最近使用次数由少到多排列，即LRU
// 这样的好处是如果要将缓存中的元素替换，则先遍历出最近最少使用的元素来替换以提高效率
private Map<String,Bitmap> cache = Collections
.synchronizedMap(new linkedHashMap<String,Bitmap>(10,1.5f,true));
// 缓存中图片所占用的字节，初始0，将通过此变量严格控制缓存所占用的堆内存
private long size = 0;// current allocated size
// 缓存只能占用的最大堆内存
private long limit = 1000000;// max memory in bytes
public MemoryCache() {
// use 25% of available heap size
setlimit(Runtime.getRuntime().maxMemory() / 4);
}
public voID setlimit(long new_limit) {
limit = new_limit;
Log.i(TAG,"MemoryCache will use up to " + limit / 1024. / 1024. + "MB");
}
public Bitmap get(String ID) {
try {
if (!cache.containsKey(ID))
return null;
return cache.get(ID);
} catch (NullPointerException ex) {
return null;
}
}
public voID put(String ID,Bitmap bitmap) {
try {
if (cache.containsKey(ID))
size -= getSizeInBytes(cache.get(ID));
cache.put(ID,bitmap);
size += getSizeInBytes(bitmap);
checkSize();
} catch (Throwable th) {
th.printstacktrace();
}
}
/**
* 严格控制堆内存，如果超过将首先替换最近最少使用的那个图片缓存
*
*/
private voID checkSize() {
Log.i(TAG,"cache size=" + size + " length=" + cache.size());
if (size > limit) {
// 先遍历最近最少使用的元素
Iterator<Entry<String,Bitmap>> iter = cache.entrySet().iterator();
while (iter.hasNext()) {
Entry<String,Bitmap> entry = iter.next();
size -= getSizeInBytes(entry.getValue());
iter.remove();
if (size <= limit)
break;
}
Log.i(TAG,"Clean cache. New size " + cache.size());
}
}
public voID clear() {
cache.clear();
}
/**
* 图片占用的内存
*
* @param bitmap
* @return
*/
long getSizeInBytes(Bitmap bitmap) {
if (bitmap == null)
return 0;
return bitmap.getRowBytes() * bitmap.getHeight();
}
}</STRONG></SPAN>

也可以使用SoftReference，代码会简单很多，但是我推荐上面的方法。
复制代码 代码如下:
public class MemoryCache {

private Map<String,SoftReference<Bitmap>> cache = Collections
.synchronizedMap(new HashMap<String,SoftReference<Bitmap>>());
public Bitmap get(String ID) {
if (!cache.containsKey(ID))
return null;
SoftReference<Bitmap> ref = cache.get(ID);
return ref.get();
}
public voID put(String ID,Bitmap bitmap) {
cache.put(ID,new SoftReference<Bitmap>(bitmap));
}
public voID clear() {
cache.clear();
}
}

下面是文件缓存类的代码fileCache.java:
复制代码 代码如下:
public class fileCache {
private file cacheDir;
public fileCache(Context context) {
// 如果有SD卡则在SD卡中建一个LazyList的目录存放缓存的图片
// 没有SD卡就放在系统的缓存目录中
if (androID.os.Environment.getExternalStorageState().equals(
androID.os.Environment.MEDIA_MOUNTED))
cacheDir = new file(
androID.os.Environment.getExternalStorageDirectory(),
"LazyList");
else
cacheDir = context.getCacheDir();
if (!cacheDir.exists())
cacheDir.mkdirs();
}
public file getfile(String url) {
// 将url的hashCode作为缓存的文件名
String filename = String.valueOf(url.hashCode());
// Another possible solution
// String filename = URLEncoder.encode(url);
file f = new file(cacheDir,filename);
return f;
}
public voID clear() {
file[] files = cacheDir.Listfiles();
if (files == null)
return;
for (file f : files)
f.delete();
}
}

最后最重要的加载图片的类，ImageLoader.java:
复制代码 代码如下:
public class ImageLoader {
MemoryCache memoryCache = new MemoryCache();
fileCache fileCache;
private Map<ImageVIEw,String> imageVIEws = Collections
.synchronizedMap(new WeakHashMap<ImageVIEw,String>());
// 线程池
ExecutorService executorService;
public ImageLoader(Context context) {
fileCache = new fileCache(context);
executorService = Executors.newFixedThreadPool(5);
}
// 当进入ListvIEw时默认的图片，可换成你自己的默认图片
final int stub_ID = R.drawable.stub;
// 最主要的方法
public voID displayImage(String url,ImageVIEw imageVIEw) {
imageVIEws.put(imageVIEw,url);
// 先从内存缓存中查找
Bitmap bitmap = memoryCache.get(url);
if (bitmap != null)
imageVIEw.setimageBitmap(bitmap);
else {
// 若没有的话则开启新线程加载图片
queuePhoto(url,imageVIEw);
imageVIEw.setimageResource(stub_ID);
}
}
private voID queuePhoto(String url,ImageVIEw imageVIEw) {
PhotoToload p = new PhotoToload(url,imageVIEw);
executorService.submit(new Photosloader(p));
}
private Bitmap getBitmap(String url) {
file f = fileCache.getfile(url);
// 先从文件缓存中查找是否有
Bitmap b = decodefile(f);
if (b != null)
return b;
// 最后从指定的url中下载图片
try {
Bitmap bitmap = null;
URL imageUrl = new URL(url);
httpURLConnection conn = (httpURLConnection) imageUrl
.openConnection();
conn.setConnectTimeout(30000);
conn.setReadTimeout(30000);
conn.setInstanceFollowRedirects(true);
inputStream is = conn.getinputStream();
OutputStream os = new fileOutputStream(f);
copyStream(is,os);
os.close();
bitmap = decodefile(f);
return bitmap;
} catch (Exception ex) {
ex.printstacktrace();
return null;
}
}
// decode这个图片并且按比例缩放以减少内存消耗，虚拟机对每张图片的缓存大小也是有限制的
private Bitmap decodefile(file f) {
try {
// decode image size
BitmapFactory.Options o = new BitmapFactory.Options();
o.inJustDecodeBounds = true;
BitmapFactory.decodeStream(new fileinputStream(f),null,o);
// Find the correct scale value. It should be the power of 2.
final int required_SIZE = 70;
int wIDth_tmp = o.outWIDth,height_tmp = o.outHeight;
int scale = 1;
while (true) {
if (wIDth_tmp / 2 < required_SIZE
|| height_tmp / 2 < required_SIZE)
break;
wIDth_tmp /= 2;
height_tmp /= 2;
scale *= 2;
}
// decode with inSampleSize
BitmapFactory.Options o2 = new BitmapFactory.Options();
o2.inSampleSize = scale;
return BitmapFactory.decodeStream(new fileinputStream(f),o2);
} catch (fileNotFoundException e) {
}
return null;
}
// Task for the queue
private class PhotoToload {
public String url;
public ImageVIEw imageVIEw;
public PhotoToload(String u,ImageVIEw i) {
url = u;
imageVIEw = i;
}
}
class Photosloader implements Runnable {
PhotoToload photoToload;
Photosloader(PhotoToload photoToload) {
this.photoToload = photoToload;
}
@OverrIDe
public voID run() {
if (imageVIEwReused(photoToload))
return;
Bitmap bmp = getBitmap(photoToload.url);
memoryCache.put(photoToload.url,bmp);
if (imageVIEwReused(photoToload))
return;
Bitmapdisplayer bd = new Bitmapdisplayer(bmp,photoToload);
// 更新的 *** 作放在UI线程中
Activity a = (Activity) photoToload.imageVIEw.getContext();
a.runOnUiThread(bd);
}
}
/**
* 防止图片错位
*
* @param photoToload
* @return
*/
boolean imageVIEwReused(PhotoToload photoToload) {
String tag = imageVIEws.get(photoToload.imageVIEw);
if (tag == null || !tag.equals(photoToload.url))
return true;
return false;
}
// 用于在UI线程中更新界面
class Bitmapdisplayer implements Runnable {
Bitmap bitmap;
PhotoToload photoToload;
public Bitmapdisplayer(Bitmap b,PhotoToload p) {
bitmap = b;
photoToload = p;
}
public voID run() {
if (imageVIEwReused(photoToload))
return;
if (bitmap != null)
photoToload.imageVIEw.setimageBitmap(bitmap);
else
photoToload.imageVIEw.setimageResource(stub_ID);
}
}
public voID clearCache() {
memoryCache.clear();
fileCache.clear();
}
public static voID copyStream(inputStream is,OutputStream os) {
final int buffer_size = 1024;
try {
byte[] bytes = new byte[buffer_size];
for (;;) {
int count = is.read(bytes,buffer_size);
if (count == -1)
break;
os.write(bytes,count);
}
} catch (Exception ex) {
}
}
}

主要流程是先从内存缓存中查找，若没有再开线程，从文件缓存中查找都没有则从指定的url中查找，并对bitmap进行处理，最后通过下面方法对UI进行更新 *** 作。
复制代码 代码如下:
a.runOnUiThread(...);

在你的程序中的基本用法：
复制代码 代码如下:
<SPAN ><STRONG>ImageLoader imageLoader=new ImageLoader(context);
...
imageLoader.displayImage(url,imageVIEw);</STRONG></SPAN>

比如你的放在你的ListVIEw的adapter的getVIEw()方法中，当然也适用于GrIDVIEw。 总结

以上是内存溢出为你收集整理的Android中加载网络资源时的优化可使用(线程+缓存)解决全部内容，希望文章能够帮你解决Android中加载网络资源时的优化可使用(线程+缓存)解决所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。