1. ¿Qué es OOM?
03-21 21:05:28.771: E/dalvikvm-heap(13316): Out of memory on a 10485776-byte allocation. 03-21 21:05:28.779: E/AndroidRuntime(13316): java.lang.OutOfMemoryError
Estas líneas significan que nuestro programa solicita 10485776byte, que es demasiado grande; la máquina virtual no puede satisfacerlo y, avergonzada, se apaga y se suicida. Este fenómeno suele aparecer en el desarrollo de apps que usan muchas imágenes o imágenes muy grandes. En términos sencillos, cuando nuestra app necesita solicitar un bloque de memoria para cargar imágenes, el sistema considera que la app ya está usando suficiente memoria. Aunque tenga 1 GB de memoria libre, no acepta darle más memoria a la app; entonces el sistema lanza inmediatamente un error OOM, y como el programa no captura ese error, aparece un cuadro de diálogo y la app se bloquea.
2. ¿Por qué ocurre OOM?
Porque cada proceso o cada máquina virtual de una app en el sistema Android tiene un límite máximo de memoria. Si los recursos de memoria solicitados superan este límite, el sistema lanza un error OOM. No tiene mucha relación con la memoria restante del dispositivo. Por ejemplo, en versiones tempranas de Android, una máquina virtual tenía como máximo 16 MB de memoria. Cuando una app se inicia, la máquina virtual solicita continuamente recursos de memoria para cargar imágenes; cuando se supera el límite de memoria, aparece OOM. ¿Cómo se determina el límite de memoria de una app en el sistema Android?
2.1 Composición de la memoria de una APP en Android:
La memoria de la app se compone dememoria Dalvikymemoria nativaSe compone de dos partes. Dalvik es el heap de Java; los objetos creados se asignan aquí. La memoria nativa se solicita mediante C/C++; Bitmap se asigna de esta manera. (Después de Android 3.0, el sistema asigna por defecto mediante Dalvik, y la nativa se gestiona como heap). La suma de estas dos partes no puede superar el límite de memoria que Android impone a un solo proceso o a una máquina virtual.
¿Cuál es el límite de memoria de cada teléfono?
ActivityManager activityManager = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE) activityManager.getMemoryClass();
El método anterior devuelve un número en unidades de M. Los valores en diferentes plataformas o dispositivos varían; por ejemplo, HTC tiene 24M por defecto, Galaxy 36M, emulator-2.3 24M, etc. Mi moto xt681 tiene 42M. 3
Lo anterior obtiene el recurso máximo de memoria de la máquina virtual.
En cuanto al límite de tamaño del heap, se puede consultar el archivo /system/build.prop.
dalvik.vm.heapstartsize = 5m dalvik.vm.heapgrowthlimit = 48m dalvik.vm.heapsize = 256m
Nota:El parámetro heapsize indica la memoria máxima disponible del heap para un solo proceso. Pero si existe el parámetro "dalvik.vm.headgrowthlimit =48m", significa que la memoria del heap para un solo proceso está limitada a 48m; es decir, durante la ejecución del programa solo se pueden usar realmente 48m de memoria.
2.2 ¿Por qué el sistema Android establece límites de memoria para las APP?
1 Para que los desarrolladores usen la memoria de manera más razonable.Limitar el límite superior de memoria disponible para cada aplicación puede impedir que algunas aplicaciones usen demasiada memoria de forma maliciosa o involuntaria, causando que otras aplicaciones no funcionen correctamente. Android tiene múltiples procesos; si un proceso (es decir, una aplicación) consume demasiada memoria, otras aplicaciones no podrán ejecutarse. Debido a esta limitación, los desarrolladores deben aprovechar al máximo los recursos limitados y optimizar el uso de los recursos.
2 El contenido que se muestra en la pantalla es limitado; basta con tener memoria suficiente.Incluso si se necesitan usar miles de imágenes y millones de datos, en un momento determinado lo que se debe mostrar al usuario siempre es limitado, porque la pantalla solo tiene ese tamaño y la información que puede contener es muy limitada. La mayor parte de la información está en estado de preparación para mostrarse, por lo que no es necesario dar demasiada memoria heap. Es decir, cuando apareceel fenómeno OOM, en la gran mayoría de los casos se debe a problemas en el diseño de nuestro programa, que necesita optimización.Hay muchos métodos de optimización, como intercambiar tiempo por espacio, cargar constantemente las imágenes que se van a usar, reciclar continuamente las imágenes que ya no se usan, y decodificar las imágenes grandes para que se ajusten al tamaño de la pantalla del teléfono, etc.
3 La necesidad de la limitación de múltiples máquinas virtuales Dalvik para múltiples aplicaciones.Las aplicaciones en Android usan máquinas virtuales independientes; cada vez que se abre una aplicación, se abre al menos una máquina virtual independiente. Esto evita que el colapso de una máquina virtual provoque el colapso de todo el sistema, pero el costo es que se desperdicia más memoria. Este diseño garantiza la estabilidad de Android.
2.3 ¿No es que GC recupera recursos automáticamente? Entonces, ¿por qué todavía ocurre OOM?
¿No utiliza Android GC para recuperar recursos automáticamente? ¿Por qué no se recuperan esos recursos no utilizados de la aplicación?
El GC de Android recupera los recursos de memoria no utilizados por el programa según un algoritmo específico, evitando que las solicitudes de memoria de la aplicación se acumulen cada vez más. Sin embargo, los recursos que GC generalmente recupera son la memoria de objetos sin propietario o recursos con referencia suave, o recursos con referencias aún más suaves. Por ejemplo:
Bitmap bt = BitmapFactory.decodeResource( this .getResources(), R.drawable.splash); //此时的图片资源是强引用,是有主的资源。 bt = null ; //此时这个图片资源就是无主的了。gc心情号的时候就会去回收它。 SoftReference<Bitmap> softRef = new SoftReference<Bitmap>(bt); bt = null ; 其他代码...
Cuando el programa solicita muchos recursos de memoria, GC puede liberar la memoria de esta imagen referenciada por softref. bt=softRef.get(); en este momento puede devolver null, por lo que es necesario volver a cargar la imagen.
Por supuesto, esto también muestra la ventaja de usar referencias suaves para los recursos de imagen: GC libera automáticamente los recursos según sea necesario, evitando OOM hasta cierto punto.
CONSEJOS: En programación, hay que adquirir el hábito de establecer los objetos que no se usan como null. En realidad, es mejor reciclar directamente las imágenes que no se usan con recycle. Porque dejar que GC los recupere mediante la asignación de null a veces no llega a tiempo.
2.4 ¿Cómo ver la asignación de memoria de una APP?
1. Supervisar el estado de la memoria mediante la pestaña heap en DDMS:
En el centro de la vista Heap hay una sección llamada "data object", es decir, objetos de datos, que son los objetos de tipo clase que existen en gran cantidad en nuestro programa.
En la fila de "data object", hay una columna llamada "Total Size"; su valor es la cantidad total de memoria de todos los objetos de datos Java en el proceso actual. Si en el código hay referencias a objetos que no se liberan, el valor de "Total Size" de "data object" no mostrará una caída evidente después de cada GC. A medida que aumentan las operaciones, el valor de "Total Size" crecerá cada vez más, hasta llegar a un límite superior y provocar que el proceso sea eliminado.
2. En la App podemos usar totalMemory y freeMemory:
Runtime.getRuntime().freeMemory() RUntime.getRuntime().totalMemory()
3 adb shell dumpsys meminfo com.android.demo
3. Algunos puntos a tener en cuenta para evitar OOM habitualmente:
3.1 Ajustar adecuadamente el tamaño de la imagenDebido a que el tamaño de la pantalla del teléfono es limitado, el área de visualización asignada a la imagen es limitada, especialmente para imágenes súper grandes cargadas desde la red o la tarjeta SD; si el tamaño del archivo de imagen alcanza varios MB o más de una decena de MB:
Antes de cargar en memoria, primero se calcula el tamaño del bitmap y luego se ajusta adecuadamente la tasa de muestreo para que la imagen cargada sea justa o ligeramente más grande, y sea suficiente para mostrarse en la pantalla del teléfono.
BimtapFactory.Option opts = new BitampFactory.Option();
opts.inJustDecodeBounds = true ;
opts.inSampleSize=computeSample(opts, minSideLength, maxNumOfPixels); // Android 提供了一种动态计算的方法 computeSampleSize
opts.inJustDecodeBounds = false ;
try {
return BitmapFactory.decodeFile(imageFile, opts);
} catch (OutOfMemoryError err){
}
3.2 Caché de imágenesCuando se cargan muchas imágenes a la vez en controles como ListView o Gallery, solo se cargan los recursos visibles en pantalla; los que aún no se muestran no se cargan, y los recursos que salen de la pantalla se liberan a tiempo. Se usa una caché de dos niveles de referencia fuerte + referencia suave para mejorar el rendimiento de carga. Se almacenan las imágenes en caché en memoria usando referencias suaves, en lugar de volver a cargarlas en memoria cada vez que se utilizan.
3.3 Usar un formato de codificación con menor uso de memoriaPor ejemplo, Bitmap.Config.ARGB_4444 ahorra más memoria que Bitmap.Config.ARGB_8888.
3.4 Reciclar imágenes oportunamenteSi 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 oportunamente 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.
Las imágenes en la pantalla de inicio (splash) de una App deben reciclarse con recycle después de usarse. Para las animaciones de fotogramas, se puede cargar una, dibujar una y liberar una.
3.5 No crear demasiadas variables locales en buclesUsa static con precaución. Cuando se usa static para modificar una variable miembro, la variable pertenece a la clase, no a la instancia de la clase, y su ciclo de vida es muy largo. Si se usa para referenciar instancias que ocupan mucha memoria, hay que tener cuidado.
3.6 Personalizar el tamaño de asignación de la memoria heapOptimizar la asignación de memoria heap de la máquina virtual Dalvik.
public class ClassName{
private static Context mContext;
// 省略
}
4. Varias formas de evitar OOM al usar imágenes en la App:
4.1 Usar directamente null o recycle.
Para la gran cantidad de imágenes utilizadas en la aplicación, se adopta el siguiente método: cargarlas cuando se usan y establecerlas directamente como null o reciclarlas con recycle cuando no se muestran.
Este manejo es un buen hábito y básicamente puede eliminar OOM, pero la desventaja es que hay más código y se podría olvidar reciclar algunos recursos.
Y en algunos casos ocurren cosas ineficientes como cargar repetidamente, liberar y volver a cargar ciertas imágenes.
4.2 Gestionar los recursos de imagen simplemente mediante el uso de SoftReference
Crear un HashMap de SoftReference
Al usar una imagen, primero consultar si este HashMap tiene una softreference y si la imagen dentro de la softreference está vacía.
Si está vacía, cargar la imagen en la softreference y agregarla al HashMap.
Ya no es necesario manejar explícitamente la recuperación y liberación de imágenes en el código; GC se encargará automáticamente de liberar los recursos.
Este método es simple y práctico de manejar, y evita hasta cierto punto la ineficiencia del método anterior de cargar y liberar repetidamente. Pero aún no está suficientemente optimizado.
4.3 Caché de dos niveles con referencia fuerte + referencia suave
El programa de ejemplo de Android ImageDownloader.java utiliza un mecanismo de caché de dos niveles. Es decir, hay una estructura de datos que mantiene directamente la referencia del objeto Bitmap decodificado correctamente, y al mismo tiempo se utiliza una estructura de datos de caché de segundo nivel para mantener los objetos SoftReference de los Bitmaps eliminados. Debido a la particularidad de los objetos SoftReference, el sistema primero liberará los objetos mantenidos por SoftReference cuando necesite memoria. Es decir, cuando la VM detecta que hay poca memoria disponible y necesita activar GC, los objetos bitmap de la caché de segundo nivel serán reclamados, mientras que los objetos bitmap mantenidos en la caché de primer nivel se utilizan para mostrarse.
De hecho, el punto más clave de esta solución es el uso de una estructura de datos bastante adecuada, es decir, el tipo LinkedHashMap como contenedor para la caché de primer nivel de Bitmaps. Debido a las particularidades de LinkedHashMap, podemos controlar el número de objetos almacenados en memoria y eliminar del contenedor los objetos que ya no se utilizan, colocándolos en la caché de segundo nivel de SoftReference. Podemos mantener de forma consistente en la caché de primer nivel los objetos bitmap a los que se ha accedido recientemente. Cuando la capacidad de LinkedHashMap supera nuestro valor preestablecido, se eliminará el objeto que haya estado más tiempo en el contenedor; en ese momento podemos colocar el objeto eliminado de LinkedHashMap en el contenedor de la caché de segundo nivel, y la gestión de los objetos de la caché de segundo nivel se deja al sistema. Cuando el sistema necesita ejecutar GC, primero reclamará los objetos Bitmap del contenedor de la caché de segundo nivel.
Al obtener el objeto de imagen, primero se busca en el contenedor de la caché de primer nivel; si hay un objeto correspondiente y está disponible, se devuelve directamente. Si no lo hay, se busca la SoftReference correspondiente en la caché de segundo nivel y se determina si el Bitmap mantenido por el objeto SoftReference está disponible; si lo está, se devuelve directamente; de lo contrario, se devuelve vacío. Si la imagen no se encuentra ni en la caché de segundo nivel, entonces se carga directamente el recurso de imagen.
4. Método de caché con LruCache + SD
5. Sugerencias para dos escenarios propensos a OOM:
5.1 Descargar una gran cantidad de imágenes desde la red
Por ejemplo, el cliente de Weibo: red asíncrona multiproceso; las imágenes pequeñas usan directamente LRUCache + SoftRef + SD, y las imágenes grandes se descargan bajo demanda:
5.2 Para los casos de ListView, GridView, etc., que necesitan cargar muchísimos elementos de información
En la función getView del adapter hay un parámetro convertView que te indica si hay un objeto view reutilizable. Si no se usa convertView, cada vez que se llama a getView se vuelve a crear una vista; así, la vista anterior puede no haber sido destruida aún, y sumado a la constante creación de nuevas vistas, inevitablemente provocará un aumento drástico de memoria, lo que conduce a OOM. Además, al reutilizar convertView, los recursos originales como las imágenes que contiene se convierten en objetos sin propietario.
Aquí Google recomienda oficialmente usar: "convertView + ViewHolder de clase estática"
La explicación oficial es:
a. Reutilizar el convertView en caché pasándolo al método getView() para evitar inflar vistas innecesarias.
b. Usar el patrón ViewHolder para evitar llamadas innecesarias a findViewById(); porque demasiadas llamadas a findViewById() también afectan al rendimiento.
El papel de la clase ViewHolder adjunta: el patrón ViewHolder almacena una estructura de datos en la etiqueta (tag) de la vista devuelta por el método getView. Esta estructura de datos contiene referencias a las vistas a las que queremos enlazar los datos, evitando así tener que llamar a findViewById() cada vez que se invoca getView().
6. Formas de solicitar asignación de memoria que exceden el límite de memoria:
6.1 Asignar memoria desde C nativo. Usando NDK (Kit de Desarrollo Nativo) y JNI, se puede asignar memoria a nivel de C (como malloc/free o new/delete); dicha asignación no cuenta dentro del límite de 24MB. Esto es cierto; la asignación de memoria desde código nativo es por conveniencia de Java, pero puede usarse para almacenar datos en la RAM (incluso datos de imágenes), lo que tiene un cierto impacto.
6.2 Usar texturas de OpenGL. La memoria de texturas no cuenta dentro del límite. Para ver cuánta memoria ha asignado realmente tu aplicación, puedes usar android.os.Debug.getNativeHeapAllocatedSize(). Usando uno de los Nexus con las dos técnicas mencionadas anteriormente, puedo asignar fácilmente 300MB para un único proceso en primer plano, más de 10 veces el límite predeterminado de 24MB. De lo anterior se desprende que asignar memoria con código nativo no está dentro del límite de 24MB (las texturas de OpenGL también usan código nativo para asignar memoria).
Sin embargo, el riesgo de estos dos métodos es que si la memoria asignada en el montón nativo supera el límite de memoria disponible del sistema, normalmente se produce un bloqueo directo.