Как реализовать кэш используя типы ссылок?

Реализация кэша с использованием типов ссылок в Android

В Android типы ссылок (Reference Types) — это механизм управления памятью, позволяющий контролировать, как объекты хранятся в памяти и когда они могут быть удалены сборщиком мусора (GC). Для реализации кэша наиболее полезны SoftReference и WeakReference, которые позволяют создавать кэши, автоматически очищаемые при необходимости.

Основные типы ссылок для кэширования

1. SoftReference – объекты сохраняются до тех пор, пока GC не потребуется память. Идеально для кэша изображений или данных, где потеря элементов допустима.
2. WeakReference – объекты удаляются сразу, как только на них нет других ссылок. Используется для вспомогательных данных или мета-информации.
3. StrongReference – обычная ссылка, объект не удаляется, пока ссылка существует.

Пример реализации LRU-кэша с SoftReference

Для кэша часто используют комбинацию LinkedHashMap (для LRU логики) и SoftReference (для автоматической очистки памяти).

import java.lang.ref.SoftReference
import java.util.LinkedHashMap

class SoftReferenceCache<K, V>(private val maxSize: Int) {
    private val cache = LinkedHashMap<K, SoftReference<V>>(maxSize, 0.75f, true)

    fun get(key: K): V? {
        val reference = cache[key]
        return reference?.get()
    }

    fun put(key: K, value: V) {
        if (cache.size >= maxSize) {
            val eldestKey = cache.keys.first()
            cache.remove(eldestKey)
        }
        cache[key] = SoftReference(value)
    }

    fun clear() {
        cache.clear()
    }
}

Ключевые особенности:

• LinkedHashMap с третьим параметром true поддерживает порядок访问 (access-order), что реализует LRU (Least Recently Used).
• Когда память требуется, GC может удалить значения внутри SoftReference, но ссылки остаются в cache. Поэтому необходимо дополнительно проверять наличие значения.

Улучшенная версия с очисткой устаревших ссылок

class ImprovedSoftReferenceCache<K, V>(private val maxSize: Int) {
    private val cache = LinkedHashMap<K, SoftReference<V>>(maxSize, 0.75f, true)

    fun get(key: K): V? {
        val reference = cache[key]
        val value = reference?.get()
        if (value == null) {
            // Удаляем пустую ссылку
            cache.remove(key)
        }
        return value
    }

    fun put(key: K, value: V) {
        cleanUp()
        if (cache.size >= maxSize) {
            val eldestKey = cache.keys.first()
            cache.remove(eldestKey)
        }
        cache[key] = SoftReference(value)
    }

    private fun cleanUp() {
        cache.entries.removeAll { entry ->
            entry.value.get() == null
        }
    }
}

Использование WeakReference для кэша метаданных

import java.lang.ref.WeakReference

class WeakMetadataCache<K, V> {
    private val cache = mutableMapOf<K, WeakReference<V>>()

    fun get(key: K): V? {
        return cache[key]?.get()
    }

    fun put(key: K, value: V) {
        cache[key] = WeakReference(value)
    }
}

Практические рекомендации

1. Выбор типа ссылки:

   • Для кэша изображений, больших данных используйте SoftReference.
   • Для временных данных, вспомогательных объектов – WeakReference.

2. Периодическая очистка: даже с SoftReference необходимо удалять пустые ссылки из карты, чтобы избежать её бесконечного роста.

3. Синхронизация: в многопоточном окружении используйте ConcurrentHashMap или синхронизацию.

4. Альтернативы: в современных Android приложениях часто используют LruCache из Android SDK или библиотеки типа Glide для изображений, которые внутренне используют похожие механизмы.

Комбинированный пример с LRU и SoftReference

import java.lang.ref.SoftReference
import java.util.concurrent.ConcurrentHashMap

class ThreadSafeSoftCache<K, V>(private val maxSize: Int) {
    private val cache = ConcurrentHashMap<K, SoftReference<V>>()
    private val accessOrder = LinkedHashSet<K>() // для отслеживания порядка

    fun get(key: K): V? {
        accessOrder.remove(key)
        accessOrder.add(key) // перемещаем в конец (самый свежий)
        val ref = cache[key]
        val value = ref?.get()
        if (value == null) cache.remove(key)
        return value
    }

    fun put(key: K, value: V) {
        if (cache.size >= maxSize) {
            val eldest = accessOrder.first()
            accessOrder.remove(eldest)
            cache.remove(eldest)
        }
        accessOrder.remove(key)
        accessOrder.add(key)
        cache[key] = SoftReference(value)
    }
}

Преимущества такого подхода:

• Автоматическое управление памятью: GC может очистить объекты при нехватке памяти.
• Сохраняет структуру кэша: даже если значения удалены, ключи остаются, что позволяет повторно загрузить данные.
• Производительность: меньше ручных проверок памяти.

Ограничения:

• Нет гарантии, что объект останется в кэше.
• Необходимо обрабатывать случаи, когда get() возвращает null.

В целом, использование типов ссылок для кэша — это баланс между производительностью и управлением памятью, особенно полезный в Android с его ограничениями по памяти. Однако в современных приложениях часто предпочитают специализированные библиотеки кэширования, которые предоставляют более богатый API и лучшую оптимизацию.