Disk Cache: o que é, cache de disco iOS e princípios de funcionamento

O que é Disk Cache no iOS?

Disk Cache é uma tecnologia para armazenar temporariamente dados no armazenamento permanente do dispositivo (memória flash) para acelerar requisições subsequentes aos mesmos dados. Ao contrário do cache RAM, o Disk Cache preserva os dados após reiniciar o aplicativo e até mesmo o dispositivo.

O iOS fornece dois níveis principais de cache: volátil (NSCache, memória) e baseado em disco (URLCache, sistema de arquivos). O cache em disco é 10 a 100 vezes mais lento que o volátil, mas significativamente mais rápido que uma requisição de rede — a diferença pode ser de 2 a 3 ordens de grandeza. A estratégia ótima utiliza um cache de dois níveis: memória para dados quentes e disco para dados frios.

De acordo com Apple Performance Optimization Guide, 2023, um Disk Cache configurado corretamente reduz o tempo de carregamento de conteúdo em 60–80% para visualizações repetidas e diminui o consumo de tráfego em 40–70%. Para aplicativos com conteúdo multimídia (imagens, vídeo, áudio), o cache é um fator crítico de UX.

URLCache: mecanismo integrado de cache

URLCache é uma classe integrada do Foundation que implementa um cache combinado para requisições URLSession. Ela salva automaticamente as respostas do servidor em disco e memória, gerenciando o tamanho do cache e as políticas de invalidação baseadas em cabeçalhos HTTP como Cache-Control, Expires e ETag.

import Foundation

let cache = URLCache(
    memoryCapacity: 50 * 1024 * 1024,
    diskCapacity: 200 * 1024 * 1024,
    diskPath: "network-cache"
)

URLCache.shared = cache

let config = URLSessionConfiguration.default
config.urlCache = cache
config.requestCachePolicy = .returnCacheDataElseLoad

let session = URLSession(configuration: config)

Políticas de cache do URLCache determinam quando usar dados em cache e quando realizar uma nova requisição. As principais políticas incluem: useProtocolCachePolicy (baseada nos cabeçalhos do servidor), reloadIgnoringLocalCacheData (sempre do servidor), returnCacheDataElseLoad (cache primeiro), returnCacheDataDontLoad (apenas cache — modo offline).

Cache-Control é um cabeçalho HTTP que o servidor envia junto com a resposta, especificando max-age (tempo de vida em segundos), must-revalidate (verificar atualidade), no-cache (não usar sem verificação) e no-store (não armazenar em cache). O iOS respeita estritamente esses cabeçalhos automaticamente ao usar URLCache com a política useProtocolCachePolicy.

Estratégias personalizadas de cache e invalidação

Cache personalizado é necessário quando o URLCache integrado é insuficiente — para armazenar imagens processadas, modelos de dados serializados ou resultados de cálculos. Nesses casos, os desenvolvedores criam seu próprio sistema de cache baseado no diretório Caches do Sandbox do aplicativo.

class DiskCache<T: Codable> {
    private let cacheDir: URL
    private let encoder = JSONEncoder()
    private let decoder = JSONDecoder()

    init() {
        let paths = FileManager.default
            .urls(for: .cachesDirectory,
                     in: .userDomainMask)
        cacheDir = paths[0].appendingPathComponent(
            "data-cache", isDirectory: true
        )
        try? FileManager.default
            .createDirectory(at: cacheDir,
                             withIntermediateDirectories: true)
    }

    func set(value: T, for key: String) {
        let url = cacheDir.appendingPathComponent(
            SHA256.hash(key)
        )
        if let data = try? encoder.encode(value) {
            try? data.write(to: url)
        }
    }

    func get(for key: String) -> T? {
        let url = cacheDir.appendingPathComponent(
            SHA256.hash(key)
        )
        guard let data = try? Data(contentsOf: url) else { return nil }
        return try? decoder.decode(T.self, from: data)
    }

    func clearAll() {
        try? FileManager.default
            .removeItem(at: cacheDir)
    }
}

Estratégias de invalidação de cache determinam quando os dados armazenados são considerados obsoletos: TTL (Time-To-Live) — os dados vivem um tempo fixo após a escrita; baseada em eventos — invalidação por evento (ex.: atualização de dados no servidor); baseada em versão — invalidação ao alterar a versão da API ou formato dos dados; LRU (Least Recently Used) — remoção automática das entradas menos utilizadas ao exceder o limite de tamanho.

Regra prática: TTL é adequado para notícias e conteúdo que se torna obsoleto de forma previsível. Baseada em eventos para dados gerenciados pelo servidor via notificações push. Baseada em versão para configurações e caches de modelos de dados. LRU é uma escolha universal para arquivos de mídia com espaço em disco limitado.

Desempenho e limitações do cache

O desempenho do Disk Cache é medido pelo hit ratio — a porcentagem de requisições satisfeitas pelo cache sem chamada de rede. Um hit ratio típico para um cache de imagens bem configurado é de 70–90%, para respostas de API — 40–60%, para vídeo em streaming — 30–50%.

Limitações do Disk Cache no iOS: o sistema pode excluir o conteúdo do diretório Caches a qualquer momento quando o espaço em disco estiver baixo. Esse comportamento não é configurável — o iOS decide quando e quais arquivos em cache excluir. Portanto, o cache não deve conter dados que não possam ser recuperados da rede ou de outras fontes.

Impacto na memória flash: a escrita frequente no Disk Cache acelera o desgaste do armazenamento flash. O iOS usa TRIM e wear leveling para minimizar o desgaste, mas recomenda-se aos desenvolvedores evitar escritas excessivas: não atualizar o cache mais de uma vez a cada 5 minutos para o mesmo arquivo; agrupar pequenas escritas; usar NSCache para dados temporários que não precisam ser persistidos em disco.

Melhores práticas de cache no iOS

Cache de dois níveis é a arquitetura padrão para aplicativos iOS: memória (NSCache) para dados acessados com frequência, e disco (URLCache ou personalizado) para dados que devem persistir entre sessões. Tempo de vida na memória — minutos, no disco — horas ou dias.

Cache de imagens: use bibliotecas especializadas (Kingfisher, SDWebImage, Nuke) que implementam um cache de dois níveis com invalidação automática, gerenciamento de memória e escrita assíncrona em disco. Implementar um cache de imagens personalizado requer consideração de decodificação, espaço de cor e escala.

Cache e segurança: não armazene dados confidenciais (senhas, tokens, dados pessoais) em disco sem criptografia. O URLCache não criptografa dados por padrão — use NSFileProtection ou criptografia em nível de aplicativo para conteúdo sensível. Para requisições de rede autorizadas, use a política .reloadIgnoringLocalCacheData.

Monitoramento de cache: acompanhe o hit ratio, o tamanho atual do cache e as escritas por minuto. Se o hit ratio cair abaixo de 30%, o cache é ineficiente e requer revisão da estratégia ou aumento de tamanho. De acordo com Point-Free (2024), o monitoramento de cache é uma das práticas de otimização de desempenho mais subestimadas em aplicativos iOS.