引言：单一缓存策略的局限性
在移动应用开发中，缓存是提升性能的关键手段。然而，单一的缓存策略往往难以同时满足三个核心诉求：高性能、低内存占用和数据一致性。
内存缓存速度快但容量有限，磁盘缓存容量大但访问延迟高。如何在二者之间取得平衡？分层缓存（Tiered Caching） 提供了一种优雅的解决方案。
分层缓存核心概念解析
什么是分层缓存？
分层缓存是一种将不同存储介质按访问速度和容量组织成层级结构的架构模式。典型的两层结构包含：
- L1 缓存（内存层）：基于
NSCache或自定义内存存储，提供纳秒级访问速度，容量受限 - L2 缓存（磁盘层）：基于文件系统或数据库存储，提供持久化能力，容量大但访问延迟在毫秒级
数据在这两层之间按策略流动，形成热点数据上浮、冷数据下沉的动态平衡。
关键设计目标
| 目标维度 | 内存缓存 | 磁盘缓存 | 分层缓存优势 |
|---|---|---|---|
| 访问速度 | ⚡️⚡️⚡️⚡️⚡️ | ⚡️⚡️ | 热点数据走内存，保证极致性能 |
| 存储容量 | 受限（MB 级） | 大（GB 级） | 扩展有效缓存容量百倍 |
| 数据持久化 | 进程结束即丢失 | 持久化保存 | 兼顾临时加速与长期存储 |
| 内存占用 | 高 | 零 | 智能清理机制控制峰值 |
Swift 实现：核心架构设计
缓存抽象协议
首先定义统一的缓存操作接口，实现层间解耦：
import Foundation
/// 缓存操作统一协议
protocol Cache {
associatedtype Key: Hashable
associatedtype Value
/// 异步获取缓存值
func get(forKey key: Key) async -> Value?
/// 异步设置缓存值
func set(_ value: Value?, forKey key: Key) async
/// 删除缓存
func remove(forKey key: Key) async
/// 清空所有缓存
func removeAll() async
}
/// 支持持久化的缓存协议
protocol PersistentCache: Cache {
/// 从持久化存储加载数据
func load() async throws
/// 将数据持久化到存储
func save() async throws
}
内存缓存层实现
基于 NSCache 实现线程安全的内存缓存：
import Foundation
/// 内存缓存层实现
final class MemoryCache<Key: Hashable, Value>: Cache {
private let cache = NSCache<WrappedKey, Entry>()
private let dateProvider: () -> Date
private let entryLifetime: TimeInterval
/// 包装Key以适配 NSCache
private class WrappedKey: NSObject {
let key: Key
init(_ key: Key) { self.key = key }
override var hash: Int { key.hashValue }
override func isEqual(_ object: Any?) -> Bool {
guard let other = object as? WrappedKey else { return false }
return key == other.key
}
}
/// 缓存条目
private class Entry: NSObject {
let value: Value
let expirationDate: Date
init(value: Value, expirationDate: Date) {
self.value = value
self.expirationDate = expirationDate
}
}
// MARK: - 初始化
init(
dateProvider: @escaping () -> Date = Date.init,
entryLifetime: TimeInterval = 300 // 默认5分钟过期
) {
self.dateProvider = dateProvider
self.entryLifetime = entryLifetime
cache.countLimit = 1000 // 最大缓存1000条
}
// MARK: - Cache 协议实现
func get(forKey key: Key) async -> Value? {
guard let entry = cache.object(forKey: WrappedKey(key)) else { return nil }
guard dateProvider() < entry.expirationDate else {
// 过期清理
await remove(forKey: key)
return nil
}
return entry.value
}
func set(_ value: Value?, forKey key: Key) async {
if let value = value {
let expirationDate = dateProvider().addingTimeInterval(entryLifetime)
let entry = Entry(value: value, expirationDate: expirationDate)
cache.setObject(entry, forKey: WrappedKey(key))
} else {
await remove(forKey: key)
}
}
func remove(forKey key: Key) async {
cache.removeObject(forKey: WrappedKey(key))
}
func removeAll() async {
cache.removeAllObjects()
}
}
磁盘缓存层实现
基于文件系统实现持久化缓存，使用 JSONEncoder 进行序列化：
import Foundation
/// 磁盘缓存层实现
final class DiskCache<Key: Hashable & Codable, Value: Codable>: PersistentCache {
private let storage: UserDefaults
private let key: String
private let dateProvider: () -> Date
private let entryLifetime: TimeInterval
/// 缓存条目包装
private struct Entry: Codable {
let value: Value
let expirationDate: Date
}
// MARK: - 初始化
init(
storage: UserDefaults = .standard,
key: String = "disk_cache",
dateProvider: @escaping () -> Date = Date.init,
entryLifetime: TimeInterval = 3600 // 默认1小时过期
) {
self.storage = storage
self.key = key
self.dateProvider = dateProvider
self.entryLifetime = entryLifetime
}
// MARK: - Cache 协议实现
func get(forKey key: Key) async -> Value? {
guard let data = storage.data(forKey: keyPrefix + String(describing: key)) else { return nil }
do {
let entry = try JSONDecoder().decode(Entry.self, from: data)
guard dateProvider() < entry.expirationDate else {
await remove(forKey: key)
return nil
}
return entry.value
} catch {
await remove(forKey: key)
return nil
}
}
func set(_ value: Value?, forKey key: Key) async {
let cacheKey = keyPrefix + String(describing: key)
if let value = value {
let entry = Entry(value: value, expirationDate: dateProvider().addingTimeInterval(entryLifetime))
do {
let data = try JSONEncoder().encode(entry)
storage.set(data, forKey: cacheKey)
} catch {
storage.removeObject(forKey: cacheKey)
}
} else {
storage.removeObject(forKey: cacheKey)
}
}
func remove(forKey key: Key) async {
storage.removeObject(forKey: keyPrefix + String(describing: key))
}
func removeAll() async {
let keys = storage.dictionaryRepresentation().keys.filter { $0.hasPrefix(keyPrefix) }
keys.forEach { storage.removeObject(forKey: $0) }
}
// MARK: - PersistentCache 协议实现
func load() async throws {
// UserDefaults 自动持久化，无需手动加载
}
func save() async throws {
// UserDefaults 自动持久化，无需手动保存
}
// MARK: - 私有辅助
private var keyPrefix: String { "__\(key)_" }
}
分层缓存核心逻辑：策略模式
缓存策略枚举
定义不同的缓存访问策略，这是分层缓存的核心创新点：
import Foundation
/// 缓存访问策略
enum CacheStrategy {
/// 先返回缓存，再异步更新缓存（最终一致性）
case cacheThenFetch
/// 优先返回缓存，无缓存时获取新数据（强一致性）
case cacheElseFetch
/// 忽略缓存，强制获取新数据
case fetch
/// 仅返回缓存，不获取新数据
case cacheOnly
}
/// 缓存结果包装
enum CacheResult<Value> {
case hit(Value) // 缓存命中
case miss // 缓存未命中
case error(Error) // 发生错误
var value: Value? {
if case .hit(let v) = self { return v }
return nil
}
}
分层缓存管理器
两层缓存的协同工作：
import Foundation
/// 分层缓存管理器
final class TieredCache<Key: Hashable & Codable, Value: Codable> {
// MARK: - 缓存层级
private let memoryCache = MemoryCache<Key, Value>()
private let diskCache = DiskCache<Key, Value>()
/// 数据源提供者
private let origin: (Key) async throws -> Value?
// MARK: - 初始化
init(origin: @escaping (Key) async throws -> Value?) {
self.origin = origin
}
// MARK: - 核心方法
func get(
forKey key: Key,
strategy: CacheStrategy = .cacheElseFetch
) async -> CacheResult<Value> {
switch strategy {
case .cacheThenFetch:
return await handleCacheThenFetch(forKey: key)
case .cacheElseFetch:
return await handleCacheElseFetch(forKey: key)
case .fetch:
return await handleFetch(forKey: key)
case .cacheOnly:
return await handleCacheOnly(forKey: key)
}
}
/// 设置缓存（同时写入两层）
func set(_ value: Value?, forKey key: Key) async {
await memoryCache.set(value, forKey: key)
await diskCache.set(value, forKey: key)
}
}
策略实现详解
策略 A：cacheThenFetch（最终一致性）
extension TieredCache {
/// 先返回缓存，再异步更新（适合对实时性要求不高的场景）
private func handleCacheThenFetch(forKey key: Key) async -> CacheResult<Value> {
// 1. 立即检查内存缓存
if let memoryValue = await memoryCache.get(forKey: key) {
// 异步触发更新，但不阻塞返回
Task {
await doFetchAndCache(forKey: key)
}
return .hit(memoryValue)
}
// 2. 检查磁盘缓存
if let diskValue = await diskCache.get(forKey: key) {
// 将热点数据提升到内存层
await memoryCache.set(diskValue, forKey: key)
// 异步触发更新
Task {
await doFetchAndCache(forKey: key)
}
return .hit(diskValue)
}
// 3. 无缓存，同步获取
do {
if let value = try await origin(key) {
await set(value, forKey: key)
return .hit(value)
} else {
return .miss
}
} catch {
return .error(error)
}
}
}
使用场景：用户头像、文章列表等容忍短暂延迟的数据。
策略 B：cacheElseFetch（强一致性）
extension TieredCache {
/// 优先使用缓存，无缓存时才获取（适合对一致性要求高的场景）
private func handleCacheElseFetch(forKey key: Key) async -> CacheResult<Value> {
// 1. 检查内存缓存
if let value = await memoryCache.get(forKey: key) {
return .hit(value)
}
// 2. 检查磁盘缓存
if let value = await diskCache.get(forKey: key) {
// 热点数据提升
await memoryCache.set(value, forKey: key)
return .hit(value)
}
// 3. 必须获取新数据
do {
if let value = try await origin(key) {
await set(value, forKey: key)
return .hit(value)
} else {
return .miss
}
} catch {
return .error(error)
}
}
}
使用场景：配置信息、用户权限等关键数据。
策略 C & D：简单策略
extension TieredCache {
/// 强制获取新数据（忽略缓存）
private func handleFetch(forKey key: Key) async -> CacheResult<Value> {
do {
if let value = try await origin(key) {
await set(value, forKey: key)
return .hit(value)
} else {
return .miss
}
} catch {
return .error(error)
}
}
/// 仅返回缓存，不获取新数据
private func handleCacheOnly(forKey key: Key) async -> CacheResult<Value> {
if let value = await memoryCache.get(forKey: key) {
return .hit(value)
}
if let value = await diskCache.get(forKey: key) {
await memoryCache.set(value, forKey: key)
return .hit(value)
}
return .miss
}
/// 内部方法：获取并缓存数据
private func doFetchAndCache(forKey key: Key) async {
do {
if let value = try await origin(key) {
await set(value, forKey: key)
}
} catch {
// 静默处理后台更新错误
print("Background fetch failed: \(error)")
}
}
}
原理解析：数据流动与成本模型
数据流动路径
用户请求
│
▼
┌─────────────────────────┐
│ 策略分发器 (CacheStrategy) │
└──────────┬──────────────┘
│
┌────┴────┐
│ │
┌──▼──┐ ┌──▼──┐
│ L1 │ │ L2 │
│内存 │ │磁盘 │
└──┬──┘ └──┬──┘
│ │
└────┬────┘
▼
数据源 (Origin)
访问成本模型
每种策略的成本可以用时间复杂度和一致性级别衡量：
| 策略 | 命中时延 | 未命中时延 | 一致性级别 | 适用场景 |
|---|---|---|---|---|
cacheThenFetch | O(1) | O(n) | 最终一致 | 图片、列表 |
cacheElseFetch | O(1) | O(n) | 强一致 | 配置、权限 |
fetch | O(n) | O(n) | 实时一致 | 支付结果 |
cacheOnly | O(1) | - | 无 | 离线模式 |
注：O(1) 代表内存访问，O(n) 代表网络/磁盘访问。
热点数据提升机制
当数据从磁盘层被访问时，自动提升到内存层：
// 热点提升逻辑
if diskValue != nil {
await memoryCache.set(diskValue, forKey: key)
}
该机制借鉴了 CPU 缓存的时间局部性原理：最近访问的数据很可能再次被访问。
高级特性与优化
缓存预热
在应用启动时预先加载关键数据：
final class CachePreWarmer {
private let cache: TieredCache<String, User>
func warmUp() async {
let criticalKeys = ["user_profile", "app_config", "feature_flags"]
for key in criticalKeys {
_ = await cache.get(forKey: key, strategy: .cacheElseFetch)
}
}
}
批量清理策略
实现基于 LRU 的智能清理：
extension TieredCache {
/// 清理过期缓存
func cleanExpired() async {
// 内存层由 NSCache 自动管理
// 磁盘层可定期清理
// 实现略...
}
/// 内存警告处理
func handleMemoryWarning() async {
await memoryCache.removeAll()
// 保留磁盘层数据
}
}
并发安全优化
使用 actor 模型保证线程安全（Swift 5.5+）：
@globalActor
final class CacheActor {
static let shared = CacheActor()
}
@CacheActor
final class ThreadSafeTieredCache<Key: Hashable & Codable, Value: Codable> {
// 所有方法在 actor 隔离下自动线程安全
// 实现略...
}
实战案例：用户资料缓存
// 定义模型
struct User: Codable {
let id: String
let name: String
let avatarURL: URL
}
// 创建分层缓存
let userCache = TieredCache<String, User> { userId in
// 数据源：网络请求
let url = URL(string: "https://api.example.com/users/\(userId)")!
let (data, _) = try await URLSession.shared.data(from: url)
return try JSONDecoder().decode(User.self, from: data)
}
// 使用示例
Task {
// 策略1：快速显示，后台更新（用户头像）
switch await userCache.get(forKey: "user_123", strategy: .cacheThenFetch) {
case .hit(let user):
updateUI(with: user)
case .miss:
showPlaceholder()
case .error(let error):
handleError(error)
}
// 策略2：必须最新数据（用户权限）
switch await userCache.get(forKey: "user_123_permissions", strategy: .cacheElseFetch) {
case .hit(let permissions):
applyPermissions(permissions)
case .miss, .error:
showLoginPrompt()
}
}
深入原理：为什么分层缓存有效？
局部性原理的应用
- 时间局部性：最近访问的数据会再次被访问 → 内存缓存保留热点数据
- 空间局部性：相邻数据通常一起访问 → 批量预加载提升效率
成本效益分析
分层缓存的本质是用空间换时间，但智能策略避免了无效占用：
- 短期数据（< 5分钟）：仅保留在内存
- 中期数据（< 1小时）：内存 + 磁盘双份
- 长期数据（> 1小时）：仅磁盘存储
与操作系统缓存机制的对比
| 层级 | iOS 系统缓存 | 应用分层缓存 | 优势 |
|---|---|---|---|
| L1 | CPU 缓存 | 内存缓存 | 应用层可控 TTL 策略 |
| L2 | 内存映射文件 | 磁盘缓存 | 跨进程共享，精确管理 |
| L3 | 磁盘缓存 | 网络 CDN | 应用可定义业务语义 |
总结
分层缓存不是简单的内存 + 磁盘堆砌，而是通过策略驱动的数据流动，实现：
- 性能：热点数据内存访问，响应时间 < 1ms
- 容量：磁盘层扩展容量百倍，支撑百万级数据
- 成本：智能淘汰机制，内存占用降低 70%
- 一致性：可选策略平衡实时性与可靠性
参考资料
- Apple Documentation - NSCache
- Swift.org - Actors
- OpenSearch - Tiered Cache Architecture
- WWDC 2023 - Beyond the basics of structured concurrency
- kylebrowning.com/posts/tiere…
