Bitmap-Arbeitsspeicher verwalten

Hinweis : In den meisten Fällen empfehlen wir die Verwendung des Glide-Bibliothek zum Abrufen, Decodieren und Bitmaps in Ihrer App anzuzeigen. Gleiten Sie abstrakt die Komplexität bei der Bewältigung dieser und weitere Aufgaben im Zusammenhang mit der Arbeit mit Bitmaps und anderen Bildern auf Android. Informationen zum Verwenden und Herunterladen von Glide finden Sie auf der Glide-Repository auf GitHub.

Zusätzlich zu den unter Bitmaps zwischenspeichern beschriebenen Schritte Es gibt bestimmte Dinge, die Sie tun können, um die automatische Speicherbereinigung und Bitmap-Wiederverwendung. Die empfohlene Strategie hängt von der oder den Version(en) ab von Android, auf das Sie Ihre Anzeigen ausrichten. Die Beispiel-App BitmapFun, die in erfahren Sie, wie Sie Ihre App so konzipieren, dass sie verschiedenen Android-Versionen vergleichen.

Um den Rahmen für diese Lektion zu schaffen, sehen wir uns an, wie die Verwaltung Bitmapspeichers hat sich weiterentwickelt:

• Unter Android 2.2 (API-Level 8) und niedriger, wenn erfasst wird, werden die Threads Ihrer App beendet. Dies führt zu einer Verzögerung, die Leistung beeinträchtigen kann. Android 2.3 fügt eine gleichzeitige automatische Speicherbereinigung hinzu, was bedeutet, wird der Speicher freigegeben, kurz nachdem auf eine Bitmap nicht mehr verwiesen wird.
• Unter Android 2.3.3 (API-Level 10) und niedriger werden die Bitmap im nativen Arbeitsspeicher gespeichert. Sie ist unabhängig von der Bitmap selbst, die im Dalvik-Heap gespeichert ist. Die Pixeldaten im nativen Arbeitsspeicher nicht vorhersehbar freigegeben wurde, was zu einer Speicherlimits kurz zu überschreiten, und stürzt ab. Ab Android 3.0 (API-Level 11) Android 7.1 (API-Ebene 25) verwendet haben, werden die Pixeldaten auf dem Dalvik-Heap zusammen mit der zugehörigen Bitmap. Unter Android 8.0 (API-Level 26) und höher werden die Bitmappixeldaten im nativen Heap gespeichert.

In den folgenden Abschnitten wird beschrieben, wie Sie den Bitmapspeicher optimieren. für verschiedene Android-Versionen verwalten.

Arbeitsspeicher unter Android 2.3.3 und niedriger verwalten

Unter Android 2.3.3 (API-Level 10) und niedriger recycle() wird empfohlen. Wenn Sie große Mengen von Bitmapdaten in Ihrer App darstellen, werden Sie wahrscheinlich auf OutOfMemoryError Fehler. Die Die Methode recycle() lässt eine App zu um so schnell wie möglich Arbeitsspeicher freizugeben.

Achtung:Verwenden Sie recycle() nur dann verwenden, wenn Sie sicher sind, dass der Bitmap wird nicht mehr verwendet. Wenn du recycle() anrufst und später versuchen, die Bitmap zu zeichnen, erhalten Sie folgende Fehlermeldung: "Canvas: trying to use a recycled bitmap".

Das folgende Code-Snippet zeigt ein Beispiel für den Aufruf recycle() Mit der Funktion zum Zählen von Referenzen (in den Variablen mDisplayRefCount und mCacheRefCount), die erfasst werden sollen ob eine Bitmap gerade angezeigt wird oder sich im Cache befindet. Die Code verwendet die Bitmap erneut, wenn diese Bedingungen erfüllt sind:

• Die Referenzanzahl für mDisplayRefCount und mCacheRefCount ist 0.
• Die Bitmap ist nicht null und wurde noch nicht recycelt.

Kotlin

private var cacheRefCount: Int = 0
private var displayRefCount: Int = 0
...
// Notify the drawable that the displayed state has changed.
// Keep a count to determine when the drawable is no longer displayed.
fun setIsDisplayed(isDisplayed: Boolean) {
    synchronized(this) {
        if (isDisplayed) {
            displayRefCount++
            hasBeenDisplayed = true
        } else {
            displayRefCount--
        }
    }
    // Check to see if recycle() can be called.
    checkState()
}

// Notify the drawable that the cache state has changed.
// Keep a count to determine when the drawable is no longer being cached.
fun setIsCached(isCached: Boolean) {
    synchronized(this) {
        if (isCached) {
            cacheRefCount++
        } else {
            cacheRefCount--
        }
    }
    // Check to see if recycle() can be called.
    checkState()
}

@Synchronized
private fun checkState() {
    // If the drawable cache and display ref counts = 0, and this drawable
    // has been displayed, then recycle.
    if (cacheRefCount <= 0
            && displayRefCount <= 0
            && hasBeenDisplayed
            && hasValidBitmap()
    ) {
        getBitmap()?.recycle()
    }
}

@Synchronized
private fun hasValidBitmap(): Boolean =
        getBitmap()?.run {
            !isRecycled
        } ?: false

Java

private int cacheRefCount = 0;
private int displayRefCount = 0;
...
// Notify the drawable that the displayed state has changed.
// Keep a count to determine when the drawable is no longer displayed.
public void setIsDisplayed(boolean isDisplayed) {
    synchronized (this) {
        if (isDisplayed) {
            displayRefCount++;
            hasBeenDisplayed = true;
        } else {
            displayRefCount--;
        }
    }
    // Check to see if recycle() can be called.
    checkState();
}

// Notify the drawable that the cache state has changed.
// Keep a count to determine when the drawable is no longer being cached.
public void setIsCached(boolean isCached) {
    synchronized (this) {
        if (isCached) {
            cacheRefCount++;
        } else {
            cacheRefCount--;
        }
    }
    // Check to see if recycle() can be called.
    checkState();
}

private synchronized void checkState() {
    // If the drawable cache and display ref counts = 0, and this drawable
    // has been displayed, then recycle.
    if (cacheRefCount <= 0 && displayRefCount <= 0 && hasBeenDisplayed
            && hasValidBitmap()) {
        getBitmap().recycle();
    }
}

private synchronized boolean hasValidBitmap() {
    Bitmap bitmap = getBitmap();
    return bitmap != null && !bitmap.isRecycled();
}

Arbeitsspeicher unter Android 3.0 und höher verwalten

Mit Android 3.0 (API-Level 11) wird die BitmapFactory.Options.inBitmap ein. Wenn diese Option festgelegt ist, decodieren Sie Methoden, die die Options Objekt versucht beim Laden von Inhalten, eine vorhandene Bitmap wiederzuverwenden. Das bedeutet, dass der Arbeitsspeicher der Bitmap wiederverwendet wird, was zu einer verbesserten Leistung führt die Speicherzuweisung und die Zuweisung aufheben. Es gibt jedoch bestimmte Einschränkungen inBitmap kann verwendet werden. Vor Android 4.4 (API-Ebene 19) werden nur Bitmaps mit gleicher Größe unterstützt. Weitere Informationen finden Sie in der inBitmap-Dokumentation.

Bitmap zur späteren Verwendung speichern

Das folgende Snippet veranschaulicht, wie eine vorhandene Bitmap für mögliche die Sie später in der Beispiel-App verwenden können. Wenn eine App unter Android 3.0 oder höher läuft und wird eine Bitmap aus LruCache entfernt, wird ein weicher Verweis auf die Bitmap platziert. in einem HashSet, zur späteren Wiederverwendung mit inBitmap:

Kotlin

var reusableBitmaps: MutableSet<SoftReference<Bitmap>>? = null
private lateinit var memoryCache: LruCache<String, BitmapDrawable>
// If you're running on Honeycomb or newer, create a
// synchronized HashSet of references to reusable bitmaps.
if (Utils.hasHoneycomb()) {
    reusableBitmaps = Collections.synchronizedSet(HashSet<SoftReference<Bitmap>>())
}

memoryCache = object : LruCache<String, BitmapDrawable>(cacheParams.memCacheSize) {

    // Notify the removed entry that is no longer being cached.
    override fun entryRemoved(
            evicted: Boolean,
            key: String,
            oldValue: BitmapDrawable,
            newValue: BitmapDrawable
    ) {
        if (oldValue is RecyclingBitmapDrawable) {
            // The removed entry is a recycling drawable, so notify it
            // that it has been removed from the memory cache.
            oldValue.setIsCached(false)
        } else {
            // The removed entry is a standard BitmapDrawable.
            if (Utils.hasHoneycomb()) {
                // We're running on Honeycomb or later, so add the bitmap
                // to a SoftReference set for possible use with inBitmap later.
                reusableBitmaps?.add(SoftReference(oldValue.bitmap))
            }
        }
    }
}

Java

Set<SoftReference<Bitmap>> reusableBitmaps;
private LruCache<String, BitmapDrawable> memoryCache;

// If you're running on Honeycomb or newer, create a
// synchronized HashSet of references to reusable bitmaps.
if (Utils.hasHoneycomb()) {
    reusableBitmaps =
            Collections.synchronizedSet(new HashSet<SoftReference<Bitmap>>());
}

memoryCache = new LruCache<String, BitmapDrawable>(cacheParams.memCacheSize) {

    // Notify the removed entry that is no longer being cached.
    @Override
    protected void entryRemoved(boolean evicted, String key,
            BitmapDrawable oldValue, BitmapDrawable newValue) {
        if (RecyclingBitmapDrawable.class.isInstance(oldValue)) {
            // The removed entry is a recycling drawable, so notify it
            // that it has been removed from the memory cache.
            ((RecyclingBitmapDrawable) oldValue).setIsCached(false);
        } else {
            // The removed entry is a standard BitmapDrawable.
            if (Utils.hasHoneycomb()) {
                // We're running on Honeycomb or later, so add the bitmap
                // to a SoftReference set for possible use with inBitmap later.
                reusableBitmaps.add
                        (new SoftReference<Bitmap>(oldValue.getBitmap()));
            }
        }
    }
....
}

Vorhandene Bitmap verwenden

In der ausgeführten App prüfen Decodermethoden, ob eine vorhandene Anwendung vorhanden ist. Bitmap darstellen, die sie verwenden können. Beispiel:

Kotlin

fun decodeSampledBitmapFromFile(
        filename: String,
        reqWidth: Int,
        reqHeight: Int,
        cache: ImageCache
): Bitmap {

    val options: BitmapFactory.Options = BitmapFactory.Options()
    ...
    BitmapFactory.decodeFile(filename, options)
    ...

    // If we're running on Honeycomb or newer, try to use inBitmap.
    if (Utils.hasHoneycomb()) {
        addInBitmapOptions(options, cache)
    }
    ...
    return BitmapFactory.decodeFile(filename, options)
}

Java

public static Bitmap decodeSampledBitmapFromFile(String filename,
        int reqWidth, int reqHeight, ImageCache cache) {

    final BitmapFactory.Options options = new BitmapFactory.Options();
    ...
    BitmapFactory.decodeFile(filename, options);
    ...

    // If we're running on Honeycomb or newer, try to use inBitmap.
    if (Utils.hasHoneycomb()) {
        addInBitmapOptions(options, cache);
    }
    ...
    return BitmapFactory.decodeFile(filename, options);
}

Das nächste Snippet zeigt die addInBitmapOptions()-Methode, die im aus. Es sucht nach einer vorhandenen Bitmap, die als Wert für inBitmap Beachten Sie, dass dies legt nur einen Wert für inBitmap fest. Wenn eine passende Übereinstimmung gefunden wird (Ihr Code sollte nie davon ausgehen, dass eine Übereinstimmung gefunden wird):

Kotlin

private fun addInBitmapOptions(options: BitmapFactory.Options, cache: ImageCache?) {
    // inBitmap only works with mutable bitmaps, so force the decoder to
    // return mutable bitmaps.
    options.inMutable = true

    // Try to find a bitmap to use for inBitmap.
    cache?.getBitmapFromReusableSet(options)?.also { inBitmap ->
        // If a suitable bitmap has been found, set it as the value of
        // inBitmap.
        options.inBitmap = inBitmap
    }
}

// This method iterates through the reusable bitmaps, looking for one
// to use for inBitmap:
fun getBitmapFromReusableSet(options: BitmapFactory.Options): Bitmap? {
    mReusableBitmaps?.takeIf { it.isNotEmpty() }?.let { reusableBitmaps ->
        synchronized(reusableBitmaps) {
            val iterator: MutableIterator<SoftReference<Bitmap>> = reusableBitmaps.iterator()
            while (iterator.hasNext()) {
                iterator.next().get()?.let { item ->
                    if (item.isMutable) {
                        // Check to see it the item can be used for inBitmap.
                        if (canUseForInBitmap(item, options)) {
                            // Remove from reusable set so it can't be used again.
                            iterator.remove()
                            return item
                        }
                    } else {
                        // Remove from the set if the reference has been cleared.
                        iterator.remove()
                    }
                }
            }
        }
    }
    return null
}

Java

private static void addInBitmapOptions(BitmapFactory.Options options,
        ImageCache cache) {
    // inBitmap only works with mutable bitmaps, so force the decoder to
    // return mutable bitmaps.
    options.inMutable = true;

    if (cache != null) {
        // Try to find a bitmap to use for inBitmap.
        Bitmap inBitmap = cache.getBitmapFromReusableSet(options);

        if (inBitmap != null) {
            // If a suitable bitmap has been found, set it as the value of
            // inBitmap.
            options.inBitmap = inBitmap;
        }
    }
}

// This method iterates through the reusable bitmaps, looking for one
// to use for inBitmap:
protected Bitmap getBitmapFromReusableSet(BitmapFactory.Options options) {
        Bitmap bitmap = null;

    if (reusableBitmaps != null && !reusableBitmaps.isEmpty()) {
        synchronized (reusableBitmaps) {
            final Iterator<SoftReference<Bitmap>> iterator
                    = reusableBitmaps.iterator();
            Bitmap item;

            while (iterator.hasNext()) {
                item = iterator.next().get();

                if (null != item && item.isMutable()) {
                    // Check to see it the item can be used for inBitmap.
                    if (canUseForInBitmap(item, options)) {
                        bitmap = item;

                        // Remove from reusable set so it can't be used again.
                        iterator.remove();
                        break;
                    }
                } else {
                    // Remove from the set if the reference has been cleared.
                    iterator.remove();
                }
            }
        }
    }
    return bitmap;
}

Schließlich bestimmt diese Methode, ob eine mögliche Bitmap die Größenkriterien für die inBitmap:

Kotlin

private fun canUseForInBitmap(candidate: Bitmap, targetOptions: BitmapFactory.Options): Boolean {
    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        // From Android 4.4 (KitKat) onward we can re-use if the byte size of
        // the new bitmap is smaller than the reusable bitmap candidate
        // allocation byte count.
        val width = ceil((targetOptions.outWidth * 1.0f / targetOptions.inSampleSize).toDouble()).toInt()
        val height = ceil((targetOptions.outHeight * 1.0f / targetOptions.inSampleSize).toDouble()).toInt()
        val byteCount: Int = width * height * getBytesPerPixel(candidate.config)
        byteCount <= candidate.allocationByteCount
    } else {
        // On earlier versions, the dimensions must match exactly and the inSampleSize must be 1
        candidate.width == targetOptions.outWidth
                && candidate.height == targetOptions.outHeight
                && targetOptions.inSampleSize == 1
    }
}

/**
 * A helper function to return the byte usage per pixel of a bitmap based on its configuration.
 */
private fun getBytesPerPixel(config: Bitmap.Config): Int {
    return when (config) {
        Bitmap.Config.ARGB_8888 -> 4
        Bitmap.Config.RGB_565, Bitmap.Config.ARGB_4444 -> 2
        Bitmap.Config.ALPHA_8 -> 1
        else -> 1
    }
}

Java

static boolean canUseForInBitmap(
        Bitmap candidate, BitmapFactory.Options targetOptions) {

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        // From Android 4.4 (KitKat) onward we can re-use if the byte size of
        // the new bitmap is smaller than the reusable bitmap candidate
        // allocation byte count.
        int width = (int) Math.ceil(targetOptions.outWidth * 1.0f / targetOptions.inSampleSize);
        int height = (int) Math.ceil(targetOptions.outHeight * 1.0f / targetOptions.inSampleSize);
        int byteCount = width * height * getBytesPerPixel(candidate.getConfig());
        return byteCount <= candidate.getAllocationByteCount();
    }

    // On earlier versions, the dimensions must match exactly and the inSampleSize must be 1
    return candidate.getWidth() == targetOptions.outWidth
            && candidate.getHeight() == targetOptions.outHeight
            && targetOptions.inSampleSize == 1;
}

/**
 * A helper function to return the byte usage per pixel of a bitmap based on its configuration.
 */
static int getBytesPerPixel(Config config) {
    if (config == Config.ARGB_8888) {
        return 4;
    } else if (config == Config.RGB_565) {
        return 2;
    } else if (config == Config.ARGB_4444) {
        return 2;
    } else if (config == Config.ALPHA_8) {
        return 1;
    }
    return 1;
}