Android OutOfMemoryError，尽管vm有足够的可用内存
尽管dalvikvm报告了足够的堆空间，但我还是发现了这个奇怪的OutOfMemoryError。日志：Android OutOfMemoryError，尽管vm有足够的可用内存,android,android-memory,Android,Android Memory,尽管dalvikvm报告了足够的堆空间，但我还是发现了这个奇怪的OutOfMemoryError。日志： 12-09 14:16:05.527: D/dalvikvm(10040): GC_FOR_ALLOC freed 551K, 21% free 38000K/47687K, paused 173ms, total 173ms 12-09 14:16:05.527: I/dalvikvm-heap(10040): Grow heap (frag case) to 38.369MB for 8
12-09 14:16:05.527: D/dalvikvm(10040): GC_FOR_ALLOC freed 551K, 21% free 38000K/47687K, paused 173ms, total 173ms
12-09 14:16:05.527: I/dalvikvm-heap(10040): Grow heap (frag case) to 38.369MB for 858416-byte allocation
12-09 14:16:05.699: D/dalvikvm(10040): GC_FOR_ALLOC freed 6K, 21% free 38832K/48583K, paused 169ms, total 169ms
12-09 14:16:05.894: D/dalvikvm(10040): GC_FOR_ALLOC freed 103K, 20% free 38929K/48583K, paused 169ms, total 169ms
12-09 14:16:05.894: I/dalvikvm-heap(10040): Forcing collection of SoftReferences for 858416-byte allocation
12-09 14:16:06.074: D/dalvikvm(10040): GC_BEFORE_OOM freed 6K, 20% free 38922K/48583K, paused 182ms, total 182ms
12-09 14:16:06.074: E/dalvikvm-heap(10040): Out of memory on a 858416-byte allocation.
12-09 14:16:06.074: I/dalvikvm(10040): "AsyncTask #2" prio=5 tid=17 RUNNABLE
12-09 14:16:06.074: I/dalvikvm(10040): | group="main" sCount=0 dsCount=0 obj=0x42013580 self=0x5f2a48d8
12-09 14:16:06.074: I/dalvikvm(10040): | sysTid=10101 nice=10 sched=0/0 cgrp=apps/bg_non_interactive handle=1591062136
12-09 14:16:06.074: I/dalvikvm(10040): | schedstat=( 7305663992 4216491759 5326 ) utm=697 stm=32 core=1
12-09 14:16:06.074: I/dalvikvm(10040): at android.graphics.BitmapFactory.nativeDecodeStream(Native Method)
12-09 14:16:06.074: I/dalvikvm(10040): at android.graphics.BitmapFactory.decodeStream(BitmapFactory.java:619)
12-09 14:16:06.074: I/dalvikvm(10040): at android.graphics.BitmapFactory.decodeStream(BitmapFactory.java:691)
mImageFetcher.loadImage(myUrl, myImageView);
public static Bitmap decodeSampledBitmapFromDescriptor(
FileDescriptor fileDescriptor, int reqWidth, int reqHeight) {
// First decode with inJustDecodeBounds=true to check dimensions
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options);
// Calculate inSampleSize
options.inSampleSize = calculateInSampleSize(options, reqWidth,
reqHeight);
// Decode bitmap with inSampleSize set
options.inJustDecodeBounds = false;
return BitmapFactory
.decodeFileDescriptor(fileDescriptor, null, options);
}
public static int calculateInSampleSize(BitmapFactory.Options options,
int reqWidth, int reqHeight) {
// Raw height and width of image
final int height = options.outHeight;
final int width = options.outWidth;
int inSampleSize = 1;
if (height > reqHeight || width > reqWidth) {
// Calculate ratios of height and width to requested height and
// width
final int heightRatio = Math.round((float) height
/ (float) reqHeight);
final int widthRatio = Math.round((float) width / (float) reqWidth);
// Choose the smallest ratio as inSampleSize value, this will
// guarantee
// a final image with both dimensions larger than or equal to the
// requested height and width.
inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
// This offers some additional logic in case the image has a strange
// aspect ratio. For example, a panorama may have a much larger
// width than height. In these cases the total pixels might still
// end up being too large to fit comfortably in memory, so we should
// be more aggressive with sample down the image (=larger
// inSampleSize).
final float totalPixels = width * height;
// Anything more than 2x the requested pixels we'll sample down
// further.
final float totalReqPixelsCap = reqWidth * reqHeight * 2;
while (totalPixels / (inSampleSize * inSampleSize) > totalReqPixelsCap) {
inSampleSize++;
}
}
return inSampleSize;
}
公共静态位图解码SampledBitMapFromDescriptor(
FileDescriptor文件描述符，int-reqWidth，int-reqHeight）{
//使用INJUSTDECBOUNDS首次解码=true检查尺寸
final BitmapFactory.Options=new BitmapFactory.Options（）；
options.inJustDecodeBounds=true；
decodeFileDescriptor（fileDescriptor，null，选项）；
//计算样本大小
options.inSampleSize=计算样本大小（选项、要求宽度、，
（高度）；
//使用inSampleSize集合解码位图
options.inJustDecodeBounds=false；
返回位图工厂
.decodeFileDescriptor（fileDescriptor，null，选项）；
}
公共静态int-calculateInSampleSize（BitmapFactory.Options、，
输入要求宽度，输入要求高度）{
//图像的原始高度和宽度
最终内部高度=options.outHeight；
最终整数宽度=options.outWidth；
int inSampleSize=1；
如果（高度>要求高度| |宽度>要求宽度）{
//计算高度和宽度与所需高度和宽度的比率
//宽度
最终整数高度比=数学圆（（浮动）高度
/（浮动）高度）；
最终整数宽度比=数学圆（（浮动）宽度/（浮动）宽度）；
//选择最小比率作为采样值，这将
//保证
//最终图像的两个尺寸均大于或等于
//要求的高度和宽度。
inSampleSize=高度比<宽度比？高度比：宽度比；
//这提供了一些额外的逻辑，以防图像有奇怪的颜色
//宽高比。例如，全景图可能具有更大的宽高比
//宽度大于高度。在这些情况下，总像素可能仍然
//结果是太大而不能舒服地放在记忆中，所以我们应该
//在图像下方采样时更具攻击性（=更大
//采样）。
最终浮点总数像素=宽度*高度；
//任何超过所需像素2倍的像素，我们将进行采样
//进一步。
最终浮点totalReqPixelsCap=reqWidth*reqHeight*2；
而（totalPixels/（inSampleSize*inSampleSize）>totalReqPixelsCap）{
inSampleSize++；
}
}
返回样本大小；
}
public Bitmap decodeSampledBitmapFromResource(String path,
int reqWidth, int reqHeight) {
// First decode with inJustDecodeBounds=true to check dimensions
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(path, options);
// BitmapFactory.decodeResource(getResources(), id)
// Calculate inSampleSize
options.inSampleSize = calculateInSampleSize(options, reqWidth,
reqHeight);
// Decode bitmap with inSampleSize set
options.inJustDecodeBounds = false;
return BitmapFactory.decodeFile(path, options);
}
public int calculateInSampleSize(BitmapFactory.Options options,
int reqWidth, int reqHeight) {
// Raw height and width of image
final int height = options.outHeight;
final int width = options.outWidth;
int inSampleSize = 1;
if (height > reqHeight || width > reqWidth) {
// Calculate ratios of height and width to requested height and
// width
final int heightRatio = Math.round((float) height
/ (float) reqHeight);
final int widthRatio = Math.round((float) width / (float) reqWidth);
// Choose the smallest ratio as inSampleSize value, this will
// guarantee
// a final image with both dimensions larger than or equal to the
// requested height and width.
inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
}
return inSampleSize;
}
公共位图解码SampledBitMapFromResource（字符串路径，
输入要求宽度，输入要求高度）{
//使用INJUSTDECBOUNDS首次解码=true检查尺寸
final BitmapFactory.Options=new BitmapFactory.Options（）；
options.inJustDecodeBounds=true；
解码文件（路径、选项）；
//BitmapFactory.decodeResource（getResources（），id）
//计算样本大小
options.inSampleSize=计算样本大小（选项、要求宽度、，
（高度）；
//使用inSampleSize集合解码位图
options.inJustDecodeBounds=false；
返回BitmapFactory.decodeFile（路径、选项）；
}
public int calculateInSampleSize（BitmapFactory.Options、，
输入要求宽度，输入要求高度）{
//图像的原始高度和宽度
最终内部高度=options.outHeight；
最终整数宽度=options.outWidth；
int inSampleSize=1；
如果（高度>要求高度| |宽度>要求宽度）{
//计算高度和宽度与所需高度和宽度的比率
//宽度
最终整数高度比=数学圆（（浮动）高度
/（浮动）高度）；
最终整数宽度比=数学圆（（浮动）宽度/（浮动）宽度）；
//选择最小比率作为采样值，这将
//保证
//最终图像的两个尺寸均大于或等于
//要求的高度和宽度。
inSampleSize=高度比<宽度比？高度比：宽度比；
}
返回样本大小；
}
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 8;
Bitmap bm=BitmapFactory.decodeFile(strPath,options);
使用inSampleSize将缩放位图加载到内存。对inSampleSize值使用2的幂对于解码器来说更快更有效。但是，如果您计划将调整大小的版本缓存在内存或磁盘上，通常仍然值得解码到最合适的映像维度以节省空间。看起来ICS和更高版本的Android不会让您的VM占用堆的总大小。我在我的应用程序中看到了同样的事情 你可以加上
android:largeHeap="true"
这会给你的应用程序带来更大的堆。不太好，但很有效…创建Imageloader类
package com.example.model;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Collections;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.widget.ImageView;
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);
}
final int stub_id=R.drawable.load;
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);
//from SD cache
Bitmap b = decodeFile(f);
if(b!=null)
return b;
//from web
try {
Bitmap bitmap=null;
URL imageUrl = new URL(url);
// System.out.println("url :"+imageUrl);
HttpURLConnection conn = (HttpURLConnection)imageUrl.openConnection();
conn.setConnectTimeout(30000);
conn.setReadTimeout(30000);
conn.setInstanceFollowRedirects(true);
InputStream is=conn.getInputStream();
OutputStream os = new FileOutputStream(f);
Utils.CopyStream(is, os);
os.close();
bitmap = decodeFile(f);
return bitmap;
} catch (Throwable ex){
ex.printStackTrace();
if(ex instanceof OutOfMemoryError)
memoryCache.clear();
return null;
}
}
//decodes image and scales it to reduce memory consumption
private Bitmap decodeFile(File f){
try {
//decode image size
BitmapFactory.Options o = new BitmapFactory.Options();
o.inJustDecodeBounds = true;
o.inPurgeable = true; // Tell to garbage collector that whether it needs free memory, the Bitmap can be cleared
o.inTempStorage = new byte[32 * 1024];
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;
long heapSize = Runtime.getRuntime().maxMemory();
long heapsize1=(heapSize/(1024*1024));
if(heapsize1>95)
{
scale*=1;
// System.out.println("scale1 :");
}else if(heapsize1>63 && heapsize1<=95){
scale*=2;
// System.out.println("scale2 :");
}else if(heapsize1>31 && heapsize1<=63){
scale*=2;
// System.out.println("scale22 :");
}else if(heapsize1>0 && heapsize1<=31){
scale*=2;
// System.out.println("scale23 :");
}
/*else if(heapsize1>31 && heapsize1<=63){
scale*=2;
// System.out.println("scale2 :");
}else if(heapsize1>0 && heapsize1<=31){
scale*=2;
// System.out.println("scale2 :");
}*/
}
//decode with inSampleSize
BitmapFactory.Options o2 = new BitmapFactory.Options();
o2.inPurgeable = true; // Tell to garbage collector that whether it needs free memory, the Bitmap can be cleared
o2.inTempStorage = new byte[32 * 1024];
o2.inSampleSize=scale;
Bitmap bitmap1=BitmapFactory.decodeStream(new FileInputStream(f), null, o2);
// System.out.println("width : "+bitmap1.getWidth()+ " height : "+bitmap1.getHeight());
/* if(bitmap1.getHeight()>=bitmap1.getWidth())
{
bitmap1 = Bitmap.createScaledBitmap(bitmap1, bitmap1.getHeight(),bitmap1.getWidth(), true);
}else{
//bmp = Bitmap.createScaledBitmap(bmp, (int) height2,width, true);
Matrix matrix = new Matrix();
matrix.postRotate(270);
bitmap1 = Bitmap.createBitmap(bitmap1 , 0, 0, bitmap1 .getWidth(), bitmap1 .getHeight(), matrix, true);
}*/
return bitmap1;
} 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);
Activity a=(Activity)photoToLoad.imageView.getContext();
a.runOnUiThread(bd);
}
}
boolean imageViewReused(PhotoToLoad photoToLoad){
String tag=imageViews.get(photoToLoad.imageView);
if(tag==null || !tag.equals(photoToLoad.url))
return true;
return false;
}
//Used to display bitmap in the UI thread
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();
}
}
package com.example.model；
导入java.io.File；
导入java.io.FileInputStream；
导入java.io.FileNotFoundException；
导入java.i
public static Bitmap decodeFile(File f,int WIDTH,int HIGHT){
try {
//Decode image size
BitmapFactory.Options o = new BitmapFactory.Options();
o.inJustDecodeBounds = true;
BitmapFactory.decodeStream(new FileInputStream(f),null,o);
//The new size we want to scale to
final int REQUIRED_WIDTH=WIDTH;
final int REQUIRED_HIGHT=HIGHT;
//Find the correct scale value. It should be the power of 2.
int scale=1;
while(o.outWidth/scale/2>=REQUIRED_WIDTH && o.outHeight/scale/2>=REQUIRED_HIGHT)
scale*=2;
//Decode with inSampleSize
BitmapFactory.Options o2 = new BitmapFactory.Options();
o2.inSampleSize=scale;
return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);
}
catch (FileNotFoundException e) {}
return null;
}