Introduction de cette section :

Dans la section précédente, nous avons déjà appris l'utilisation de base de Bitmap. Dans cette section, nous allons discuter des problèmes d'OOM causés par Bitmap. Vous avez peut-être ou non rencontré des problèmes d'OOM causés par Bitmap lors du développement réel. Dans cette section, nous allons étudier ce sujet : comprendre ce qu'est l'OOM, pourquoi il provoque des OOM, et améliorer les problèmes d'OOM causés par Bitmap.


1. Qu'est-ce que l'OOM ? Pourquoi provoque-t-il des OOM ?

Réponse :Mémoire insuffisante(Out of Memory). Nous savons tous que le système Android alloue un espace de travail indépendant pour chaque application, ou alloue une machine virtuelle Dalvik distincte, afin que chaque application puisse s'exécuter indépendamment sans affecter les autres ! Android a une limite de mémoire maximale pour chaque machine virtuelle Dalvik. Si la mémoire actuellement occupée additionnée aux ressources mémoire que nous demandons dépasse cette limite, le système lèvera une erreur OOM ! De plus, ne confondez pas cela avec la RAM. Même s'il reste plus de 1G de RAM, un OOM peut toujours se produire ! N'assimilez pas la RAM (mémoire physique) à l'OOM ! De plus, si la RAM est insuffisante, l'application est tuée, pas seulement un OOM ! La norme de mémoire maximale dans Dalvik varie selon les appareils. Vous pouvez appeler :

ActivityManager activityManager = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);
Log.e("HEHE","最大内存:" + activityManager.getMemoryClass());

pour obtenir le standard normal de mémoire maximale, ou tapez directement dans la ligne de commande :

adb shell getprop | grep dalvik.vm.heapgrowthlimit

Vous pouvez également ouvrir le fichier /system/build.prop du code source système, et regarder cette partie des informations dans le fichier pour la trouver :

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

Trois endroits nous intéressent : heapstartsize est la taille initiale de la mémoire du tas, heapgrowthlimit est la taille maximale de la mémoire du tas d'une application standard, et heapsize est la taille maximale de la mémoire du tas d'une application configurée pour utiliser android:largeHeap !

J'ai testé ici les standards normaux d'allocation mémoire maximale de quelques appareils à portée de main :

Vous pouvez aussi essayer votre propre appareil.

Bon, assez de digression. Concernant l'apparition des problèmes d'OOM, nous nous arrêterons ici. Si nous allions plus loin, nous arriverions à la gestion de la mémoire, qui est un vaste sujet et trop difficile à aborder maintenant... Ci-dessous, examinons quelques astuces pour éviter les OOM causés par Bitmap !


2. Récapitulatif des astuces pour éviter les OOM causés par Bitmap


1) Utiliser une méthode d'encodage peu gourmande en mémoire

Comme mentionné dans la section précédenteBitmapFactory.OptionsDans cette classe, nous pouvons définir sa propriété inPreferredConfig, qui est par défautBitmap.Config.ARGB_8888, nous pouvons la changer en :Bitmap.Config.ARGB_4444
Bitmap.Config ARGB_4444 : chaque pixel occupe quatre bits, soit A=4, R=4, G=4, B=4, donc un pixel occupe 4+4+4+4=16 bits
Bitmap.Config ARGB_8888 : chaque pixel occupe huit bits, soit A=8, R=8, G=8, B=8, donc un pixel occupe 8+8+8+8=32 bits
Par défaut, ARGB_8888 est utilisé, ce qui signifie qu'un pixel occupe 4 octets !


2) Compression d'image

Toujours en utilisant BitmapFactory.Options, nous pouvons utiliserinSampleSizepour définir le facteur d'échelle. Par exemple, définir 2 signifie que la largeur et la hauteur deviennent 1/2 de l'original, et l'image devient 1/4 de l'original. Si aucune mise à l'échelle n'est nécessaire, définissez-la sur 1. Cependant, vous ne pouvez pas compresser aveuglément. Après tout, si cette valeur est trop petite, l'image sera très floue, et vous devez éviter l'étirement et la distorsion. Par conséquent, nous devons calculer dynamiquement la valeur appropriée de inSampleSize dans le programme. Options dispose également d'une telle méthode :inJustDecodeBoundsAprès avoir défini ce paramètre sur true, decodeFile n'allouera pas d'espace mémoire, mais il peut calculer la largeur et la hauteur de l'image d'origine. Appelez options.outWidth/outHeightpour obtenir la largeur et la hauteur de l'image, puis grâce à un certain algorithme, vous pouvez obtenir une valeur inSampleSize appropriée. Merci ici àJie Shenpour avoir fourni le code — extrait du 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;
}

Ensuite, vous pouvez utiliser la méthode ci-dessus :

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. Recyclez rapidement les images

Si un grand nombre d’objets Bitmap sont référencés et que l’application n’a pas besoin d’afficher toutes les images en même temps, vous pouvez recycler rapidement les objets Bitmap dont vous n’avez pas besoin temporairement. Pour certains scénarios où l’utilisation des images est clairement connue, vous pouvez appeler activement recycle pour les récupérer, comme les images de la page de guide : recyclez-les après utilisation. Pour l’animation image par image, chargez-en une, dessinez-en une, libérez-en une ! Chargez-les lorsqu’elles sont utilisées, et mettez directement à null ou recyclez lorsqu’elles ne sont pas affichées ! Par exemple : imageView.setImageResource(0); Cependant, dans certains cas, il y aura des choses inefficaces comme charger, libérer et recharger de façon répétée une image spécifique...


4. Autres méthodes

Je n’ai pas utilisé les méthodes suivantes. Vous pouvez consulter vous-même la documentation pertinente :

1. Utiliser simplement SoftReference pour gérer les ressources d’images

Créez un HashMap de SoftReference. Lorsque vous utilisez une image, vérifiez d’abord si ce HashMap contient une SoftReference et si l’image dans la SoftReference est vide. Si elle est vide, chargez l’image dans la SoftReference et ajoutez-la au HashMap. Il n’est pas nécessaire de gérer explicitement le recyclage et la libération des images dans le code ; le GC gérera automatiquement la libération des ressources. Cette méthode est simple et pratique, et peut éviter dans une certaine mesure l’inefficacité du chargement et de la libération répétés de la méthode précédente. Mais elle n’est pas suffisamment optimisée.

Exemple de code :

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. Approche de mise en cache LruCache + carte SD

Depuis Android 3.1, LruCache est officiellement fourni pour la gestion du cache. Lorsque la taille des images stockées dépasse la valeur définie par LruCache, les images les moins récemment utilisées seront recyclées, et le système libérera automatiquement la mémoire !

Exemple d'utilisation:

Étapes:

1) Tout d’abord, définissez la taille mémoire des images mises en cache. Ici, je la définis à 1/8 de la mémoire du téléphone. Comment obtenir la mémoire du téléphone : int MAXMEMONRY = (int) (Runtime.getRuntime() .maxMemory() / 1024);

2) Les paires clé-valeur dans LruCache sont l’URL et l’image correspondante.

3) Redéfinissez une méthode appelée sizeOf, qui renvoie le nombre d'images.

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) Les méthodes suivantes sont : vider le cache, ajouter une image au cache, obtenir une image depuis le cache, et supprimer une image du cache.

La suppression et le vidage du cache sont indispensables, car une mauvaise gestion du cache d'images provoquera des erreurs de mémoire insuffisante, donc vous devez y faire attention.

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();
        }
    }
}

Le contenu ci-dessus est extrait de —Mise en cache d'images : technologie de cache mémoire LruCache, références souples


Résumé de cette section :

Dans cette section, nous avons expliqué la cause des problèmes d'OOM et résumé quelques solutions trouvées en ligne pour éviter les OOM causés par Bitmap. Comme les applications que mon entreprise développe sont toutes liées aux cartes et impliquent rarement des images, l'auteur n'a jamais rencontré de problèmes d'OOM, donc je ne suis pas très familier avec cela. Plus tard, dans le cours avancé sur la gestion de la mémoire, nous traiterons progressivement ce problème d'OOM. Bon, c'est tout pour cette section, merci.


Références: Analyse et solutions des problèmes d'OOM dans les applications Android