Einführung in diesen Abschnitt:
Im vorherigen Abschnitt haben wir bereits die grundlegende Verwendung von Bitmap kennengelernt. In diesem Abschnitt besprechen wir die durch Bitmap verursachten OOM-Probleme. Möglicherweise sind Ihnen bei der tatsächlichen Entwicklung OOM-Probleme durch Bitmap begegnet oder auch nicht. In diesem Abschnitt werden wir dieses Thema untersuchen: verstehen, was OOM ist, warum es OOM verursacht, und die durch Bitmap verursachten OOM-Probleme verbessern.
1. Was ist OOM? Warum verursacht es OOM?
Antwort:Out Of Memory(Out of Memory). Wir alle wissen, dass das Android-System für jede App einen unabhängigen Arbeitsbereich zuweist oder eine separate Dalvik-virtuelle Maschine bereitstellt, damit jede App unabhängig laufen kann, ohne sich gegenseitig zu beeinflussen! Android hat ein maximales Speicherlimit für jede Dalvik-virtuelle Maschine. Wenn der aktuell belegte Speicher plus die Speicherressourcen, die wir anfordern, dieses Limit überschreitet, löst das System einen OOM-Fehler aus! Verwechseln Sie dies außerdem nicht mit RAM. Selbst wenn mehr als 1G RAM übrig ist, kann OOM immer noch auftreten! Setzen Sie RAM (physischer Speicher) nicht mit OOM gleich! Wenn außerdem der RAM nicht ausreicht, wird die Anwendung beendet, nicht nur OOM! Der maximale Speicherstandard in Dalvik variiert je nach Gerät. Sie können aufrufen:
ActivityManager activityManager = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);
Log.e("HEHE","最大内存:" + activityManager.getMemoryClass());
um den normalen maximalen Speicherstandard zu erhalten, oder geben Sie direkt in der Kommandozeile ein:
adb shell getprop | grep dalvik.vm.heapgrowthlimit
Sie können auch die Systemquellcode-Datei /system/build.prop öffnen und diesen Teil der Informationen in der Datei nachsehen, um es herauszufinden:
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
Es gibt drei Stellen, die uns interessieren: heapstartsize ist die Anfangsgröße des Heap-Speichers, heapgrowthlimit ist die maximale Heap-Speichergröße einer Standardanwendung, und heapsize ist die maximale Heap-Speichergröße einer Anwendung, die auf android:largeHeap gesetzt ist!
Hier habe ich die normalen maximalen Speicherzuweisungsstandards einiger Geräte zur Hand getestet:
Sie können auch Ihr eigenes Gerät ausprobieren.
Also gut, genug abgeschweift. Was die Entstehung von OOM-Problemen betrifft, hören wir hier auf. Wenn wir weiter gehen, würden wir zur Speicherverwaltung gelangen, was ein großes Thema ist und jetzt zu schwer anzugehen ist... Im Folgenden schauen wir uns einige Tipps zur Vermeidung von Bitmap-OOM an!
2. Zusammenfassung der Tipps zur Vermeidung von durch Bitmap verursachtem OOM
1) Verwenden Sie eine Kodierungsmethode mit geringem Speicherverbrauch
Wie im vorherigen Abschnitt erwähntBitmapFactory.OptionsIn dieser Klasse können wir ihre inPreferredConfig-Eigenschaft festlegen, die standardmäßigBitmap.Config.ARGB_8888ist, und wir können sie ändern in:Bitmap.Config.ARGB_4444
Bitmap.Config ARGB_4444: Jedes Pixel belegt vier Bits, d. h. A=4, R=4, G=4, B=4, also belegt ein Pixel 4+4+4+4=16 Bits
Bitmap.Config ARGB_8888: Jedes Pixel belegt acht Bits, d. h. A=8, R=8, G=8, B=8, also belegt ein Pixel 8+8+8+8=32 Bits
Standardmäßig wird ARGB_8888 verwendet, was bedeutet, dass ein Pixel 4 Bytes belegt!
2) Bildkomprimierung
Mit BitmapFactory.Options können wir weiterhininSampleSizeverwenden, um den Skalierungsfaktor festzulegen. Wenn man beispielsweise 2 einstellt, werden Breite und Höhe auf 1/2 des Originals reduziert und das Bild auf 1/4 des Originals. Wenn keine Skalierung erforderlich ist, setzt man es auf 1. Man kann jedoch nicht blind komprimieren. Schließlich ist das Bild sehr unscharf, wenn dieser Wert zu klein ist, und Sie müssen Dehnung und Verzerrung vermeiden. Daher müssen wir den geeigneten Wert von inSampleSize im Programm dynamisch berechnen. Options hat auch eine solche Methode:inJustDecodeBoundsNachdem dieser Parameter auf true gesetzt wurde, weist decodeFile keinen Speicherplatz zu, kann aber die Breite und Höhe des Originalbilds berechnen. Rufen Sie options.outWidth/outHeightauf, um die Breite und Höhe des Bildes zu erhalten; dann können Sie durch einen bestimmten Algorithmus einen geeigneten inSampleSize erhalten. Dank hier anJie Shenfür die Bereitstellung des Codes — entnommen aus Hongyangs Blog!
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;
}
Dann können Sie die obige Methode verwenden:
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. Bilder zeitnah recyceln
Wenn eine große Anzahl von Bitmap-Objekten referenziert wird und die Anwendung nicht alle Bilder gleichzeitig anzeigen muss, können Sie die vorübergehend nicht benötigten Bitmap-Objekte zeitnah recyceln. In einigen Szenarien, in denen die Verwendung der Bilder klar bekannt ist, können Sie recycle aktiv aufrufen, um sie zurückzugewinnen, z. B. Bilder auf der Anleitungsseite: Recyceln Sie sie nach der Verwendung. Bei Frame-Animationen: eines laden, eines zeichnen, eines freigeben! Laden Sie bei Verwendung und setzen Sie es direkt auf null oder rufen Sie recycle auf, wenn es nicht angezeigt wird! Zum Beispiel: imageView.setImageResource(0); In einigen Fällen gibt es jedoch ineffiziente Dinge wie wiederholtes Laden, Freigeben und erneutes Laden eines bestimmten Bildes...
4. Andere Methoden
Die folgenden Methoden habe ich nicht verwendet. Sie können sich selbst über relevante Materialien informieren:
1. Verwenden Sie einfach SoftReference, um Bildressourcen zu verwalten
Erstellen Sie eine HashMap aus SoftReference. Wenn Sie ein Bild verwenden, prüfen Sie zuerst, ob diese HashMap eine SoftReference enthält und ob das Bild in der SoftReference leer ist. Wenn es leer ist, laden Sie das Bild in die SoftReference und fügen Sie es der HashMap hinzu. Es ist nicht nötig, das Recyceln und Freigeben von Bildern im Code explizit zu behandeln; der GC übernimmt die Ressourcenfreigabe automatisch. Diese Methode ist einfach und praktisch und kann bis zu einem gewissen Grad die Ineffizienz des wiederholten Ladens und Freigebens in der vorherigen Methode vermeiden. Sie ist jedoch nicht optimiert genug.
Beispielcode:
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. LruCache + SD-Karten-Caching-Ansatz
Seit Android 3.1 wird offiziell LruCache für die Cache-Verarbeitung bereitgestellt. Wenn die Größe der gespeicherten Bilder den von LruCache festgelegten Wert überschreitet, werden die am längsten nicht verwendeten Bilder recycelt, und das System gibt Speicher automatisch frei!
Anwendungsbeispiel:
Schritte:
1) Legen Sie zuerst die Speichergröße der zwischengespeicherten Bilder fest. Hier habe ich sie auf 1/8 des Telefonspeichers gesetzt. So rufen Sie den Telefonspeicher ab: int MAXMEMONRY = (int) (Runtime.getRuntime() .maxMemory() / 1024);
2) Die Schlüssel-Wert-Paare in LruCache sind die URL und das entsprechende Bild.
3) Überschreiben Sie eine Methode namens sizeOf, die die Anzahl der Bilder zurückgibt.
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) Die folgenden Methoden sind: den Cache leeren, ein Bild zum Cache hinzufügen, ein Bild aus dem Cache abrufen und ein Bild aus dem Cache entfernen.
Das Entfernen und Leeren des Caches ist ein Muss, denn ein unsachgemäßer Umgang mit dem Bildcache führt zu Out-of-Memory-Fehlern, daher müssen Sie darauf achten.
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();
}
}
}
Der obige Inhalt ist entnommen aus —Bild-Caching: Speichercache-Technologie LruCache, Soft References
Zusammenfassung dieses Abschnitts:
In diesem Abschnitt haben wir die Ursache von OOM-Problemen erklärt und einige online gefundene Lösungen zusammengefasst, um durch Bitmap verursachte OOM zu vermeiden. Da die Apps, die meine Firma erstellt, alle kartenbezogen sind und selten Bilder betreffen, ist der Autor noch nie auf OOM-Probleme gestoßen, daher bin ich damit nicht sehr vertraut. Später, im Fortgeschrittenenkurs zum Speichermanagement, werden wir uns allmählich mit diesem OOM-Problem befassen. Okay, das war's für diesen Abschnitt, danke.
Referenzen: Analyse und Lösungen von OOM-Problemen in Android-Anwendungen