Introducción a esta sección:
En la sección anterior, ya hemos aprendido el uso básico de Bitmap, y en esta sección vamos a explorar el problema de OOM de Bitmap. En el desarrollo real, es posible que hayan encontrado, o no, problemas de OOM causados por Bitmap. En esta sección vamos a aprender en torno a este tema: comprender qué es OOM, por qué causa OOM y mejorar el problema de OOM causado por Bitmap.
1. ¿Qué es OOM? ¿Por qué causa OOM?
Respuesta:Out Of Memory(Desbordamiento de memoria). Todos sabemos que el sistema Android asigna a cada APP un espacio de trabajo independiente, o mejor dicho, asigna una máquina virtual Dalvik separada, de modo que cada APP puede ejecutarse de forma independiente sin afectarse mutuamente. Android tiene un límite máximo de memoria para cada máquina virtual Dalvik. Si la memoria actualmente ocupada más los recursos de memoria que solicitamos superan este límite, el sistema lanzará un error OOM. Además, no lo confundas con la RAM. Aunque quede más de 1G de memoria restante en la RAM, OOM aún puede ocurrir. No mezcles la RAM (memoria física) con OOM. Además, si la RAM es insuficiente, se matará la aplicación, no solo OOM. El estándar de memoria máxima en Dalvik varía según el modelo de dispositivo. Se puede llamar a:
ActivityManager activityManager = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);
Log.e("HEHE","最大内存:" + activityManager.getMemoryClass());
para obtener el estándar normal de memoria máxima, o escribir directamente en la línea de comandos:
adb shell getprop | grep dalvik.vm.heapgrowthlimit
También puedes abrir el archivo de código fuente del sistema /system/build.prop y ver la información de esta parte del archivo para obtener:
dalvik.vm.heapstartsize=8m dalvik.vm.heapgrowthlimit=192m dalvik.vm.heapsize=512m dalvik.vm.heaptargetutilization=0.75 dalvik.vm.heapminfree=2m dalvik.vm.heapmaxfree=8m
Hay tres lugares a los que prestamos atención: heapstartsize es el tamaño inicial del montón de memoria, heapgrowthlimit es el tamaño máximo de montón para aplicaciones estándar, y heapsize es el tamaño máximo de montón para aplicaciones que usan android:largeHeap.
Aquí probé el estándar de asignación de memoria máxima normal de varios modelos que tengo a mano:
También puedes probar con el dispositivo que tengas a mano.
Bueno, no nos desviemos más. Sobre la generación del problema OOM, lo dejamos aquí. Si seguimos, llegaríamos a la gestión de memoria, que es un tema grande y aún no podemos abordarlo. A continuación, veamos algunos consejos para evitar el OOM de Bitmap.
2. Resumen de técnicas para evitar OOM causado por Bitmap
1) Adoptar un método de codificación con baja ocupación de memoria
Como se dijo en la sección anteriorBitmapFactory.OptionsEsta clase, podemos configurar su propiedad inPreferredConfig, por defecto esBitmap.Config.ARGB_8888, podemos cambiarlo aBitmap.Config.ARGB_4444
Bitmap.Config ARGB_4444: cada píxel ocupa cuatro bits, es decir, A=4, R=4, G=4, B=4, por lo que un píxel ocupa 4+4+4+4=16 bits.
Bitmap.Config ARGB_8888: cada píxel ocupa ocho bits, es decir, A=8, R=8, G=8, B=8, por lo que un píxel ocupa 8+8+8+8=32 bits.
Por defecto se usa ARGB_8888, es decir, un píxel ocupa 4 bytes.
2) Compresión de imágenes
También con BitmapFactory.Options, medianteinSampleSizese establece el factor de escala. Por ejemplo, si se escribe 2, el ancho y el alto se convierten en 1/2 del original, y la imagen será 1/4 del original. Si no se quiere escalar, se establece en 1. Pero no se puede comprimir sin límite; después de todo, si este valor es demasiado pequeño, la imagen se verá borrosa, y también hay que evitar la deformación por estiramiento. Por lo tanto, necesitamos calcular dinámicamente el valor apropiado de inSampleSize en el programa, y Options tiene otro método así:inJustDecodeBounds, después de establecer este parámetro en true, decodeFiel no asignará espacio de memoria, pero puede calcular el ancho y alto de la imagen original. Llame a options.outWidth/outHeightpara obtener el ancho y alto de la imagen, y luego mediante cierto algoritmo se puede obtener el inSampleSize adecuado. Aquí agradecemos aJie Shenpor el código proporcionado, extraído del blog de Hongyang.
public static int caculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
int width = options.outWidth;
int height = options.outHeight;
int inSampleSize = 1;
if (width > reqWidth || height > reqHeight) {
int widthRadio = Math.round(width * 1.0f / reqWidth);
int heightRadio = Math.round(height * 1.0f / reqHeight);
inSampleSize = Math.max(widthRadio, heightRadio);
}
return inSampleSize;
}
Luego simplemente usa el método mencionado anteriormente:
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true; // 设置了此属性一定要记得将值设置为false
Bitmap bitmap = null;
bitmap = BitmapFactory.decodeFile(url, options);
options.inSampleSize = computeSampleSize(options,128,128);
options.inPreferredConfig = Bitmap.Config.ARGB_4444;
/* 下面两个字段需要组合使用 */
options.inPurgeable = true;
options.inInputShareable = true;
options.inJustDecodeBounds = false;
try {
bitmap = BitmapFactory.decodeFile(url, options);
} catch (OutOfMemoryError e) {
Log.e(TAG, "OutOfMemoryError");
}
3. Reciclar imágenes de manera oportuna
Si se hace referencia a una gran cantidad de objetos Bitmap y la aplicación no necesita mostrar todas las imágenes al mismo tiempo, se pueden reciclar de manera oportuna los objetos Bitmap que no se usen temporalmente. Para algunos escenarios donde se conoce claramente el uso de las imágenes, se puede reciclar activamente con recycle. Por ejemplo, las imágenes de la página de guía, después de usarlas se reciclan; en la animación de fotogramas, se carga una, se dibuja una, se libera una. Se cargan al usarse, y cuando no se muestran, se establecen directamente a null o se reciclan. Por ejemplo: imageView.setImageResource(0); Sin embargo, en algunos casos puede ocurrir la carga, liberación y recarga repetida de ciertas imágenes, lo cual es ineficiente...
4. Otros métodos
Los siguientes métodos no los he usado; pueden consultar la información relevante por su cuenta:
1. Gestionar recursos de imagen simplemente mediante referencias SoftReference
Crear un HashMap de SoftReference. Al usar una imagen, primero consulta si este HashMap tiene la softreference y si la imagen dentro de la softreference está vacía. Si está vacía, carga la imagen en la softreference y agrégala al HashMap. No es necesario manejar explícitamente el reciclaje y liberación de imágenes en el código; el GC se encargará automáticamente de liberar recursos. Este método es simple y práctico, y puede evitar en cierta medida la ineficiencia de carga y liberación repetidas del método anterior. Pero aún no está lo suficientemente optimizado.
Código de ejemplo:
private Map<String, SoftReference<Bitmap>> imageMap
= new HashMap<String, SoftReference<Bitmap>>();
public Bitmap loadBitmap(final String imageUrl,final ImageCallBack imageCallBack) {
SoftReference<Bitmap> reference = imageMap.get(imageUrl);
if(reference != null) {
if(reference.get() != null) {
return reference.get();
}
}
final Handler handler = new Handler() {
public void handleMessage(final android.os.Message msg) {
//加入到缓存中
Bitmap bitmap = (Bitmap)msg.obj;
imageMap.put(imageUrl, new SoftReference<Bitmap>(bitmap));
if(imageCallBack != null) {
imageCallBack.getBitmap(bitmap);
}
}
};
new Thread(){
public void run() {
Message message = handler.obtainMessage();
message.obj = downloadBitmap(imageUrl);
handler.sendMessage(message);
}
}.start();
return null ;
}
// 从网上下载图片
private Bitmap downloadBitmap (String imageUrl) {
Bitmap bitmap = null;
try {
bitmap = BitmapFactory.decodeStream(new URL(imageUrl).openStream());
return bitmap ;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public interface ImageCallBack{
void getBitmap(Bitmap bitmap);
}
2. Método de caché LruCache + tarjeta SD
A partir de Android 3.1, oficialmente se proporciona LruCache para el manejo de caché. Cuando el tamaño de las imágenes almacenadas supera el valor establecido por LruCache, la imagen utilizada menos recientemente se reciclará y el sistema liberará memoria automáticamente.
Ejemplo de uso:
Pasos:
1) Primero se debe establecer el tamaño de memoria para la caché de imágenes. Aquí lo configuro como 1/8 de la memoria del teléfono. La forma de obtener la memoria del teléfono: int MAXMEMONRY = (int) (Runtime.getRuntime() .maxMemory() / 1024);
2) Los pares clave-valor en LruCache son la URL y la imagen correspondiente.
3) Se sobrescribe un método llamado sizeOf, que devuelve la cantidad de imágenes.
private LruCache<String, Bitmap> mMemoryCache;
private LruCacheUtils() {
if (mMemoryCache == null)
mMemoryCache = new LruCache<String, Bitmap>(
MAXMEMONRY / 8) {
@Override
protected int sizeOf(String key, Bitmap bitmap) {
// 重写此方法来衡量每张图片的大小,默认返回图片数量。
return bitmap.getRowBytes() * bitmap.getHeight() / 1024;
}
@Override
protected void entryRemoved(boolean evicted, String key,
Bitmap oldValue, Bitmap newValue) {
Log.v("tag", "hard cache is full , push to soft cache");
}
};
}
4) Los métodos siguientes son, respectivamente, vaciar la caché, agregar imágenes a la caché, obtener imágenes de la caché y eliminar imágenes de la caché.
Eliminar y vaciar la caché es algo que se debe hacer, porque un manejo inadecuado de la caché de imágenes provocará un desbordamiento de memoria, por lo que hay que prestar atención.
public void clearCache() {
if (mMemoryCache != null) {
if (mMemoryCache.size() > 0) {
Log.d("CacheUtils",
"mMemoryCache.size() " + mMemoryCache.size());
mMemoryCache.evictAll();
Log.d("CacheUtils", "mMemoryCache.size()" + mMemoryCache.size());
}
mMemoryCache = null;
}
}
public synchronized void addBitmapToMemoryCache(String key, Bitmap bitmap) {
if (mMemoryCache.get(key) == null) {
if (key != null && bitmap != null)
mMemoryCache.put(key, bitmap);
} else
Log.w(TAG, "the res is aready exits");
}
public synchronized Bitmap getBitmapFromMemCache(String key) {
Bitmap bm = mMemoryCache.get(key);
if (key != null) {
return bm;
}
return null;
}
/**
* 移除缓存
*
* @param key
*/
public synchronized void removeImageCache(String key) {
if (key != null) {
if (mMemoryCache != null) {
Bitmap bm = mMemoryCache.remove(key);
if (bm != null)
bm.recycle();
}
}
}
El contenido anterior está extraído de—Tecnología de caché de memoria para imágenes LruCache, SoftReference
Resumen de esta sección:
En esta sección explicamos las causas del problema OOM y también resumimos algunas soluciones encontradas en Internet para evitar el OOM causado por Bitmap. Como las aplicaciones que hace la empresa son todas de mapas, rara vez involucran imágenes, por lo que el autor no ha encontrado problemas de OOM y no está muy familiarizado con esto. Más adelante, en la gestión de memoria del curso avanzado, abordaremos lentamente este problema de OOM. Bien, esto es todo por esta sección, gracias.
Referencias: Análisis y soluciones del problema OOM en aplicaciones Android