• Flutter 应用加速之本地缓存管理

    前言

    村里的老人说：“不会写缓存器的码农不是好程序员。”

    今天我们就来讲讲如何编写一个简单又通用的缓存管理模块。

    需求分析

    根据以往经验，每一个缓存器，除了要保持被缓存数据/对象之外，还需要同时记录两个与之紧密相关的时间：

    1. 过期时间 expired —— 缓存超过了一定时间，需要更新了，但当前数据仍然有效
    2. 失效时间 deprecated —— 缓存超过了很长时间，当前数据已经无效，不能再用了

    在过期时间 expired 之前，缓存数据/对象可直接使用，无需刷新；
    超过了过期时间 expired，但未超过失效时间 deprecated，此时缓存数据仍然有效，可以继续使用，但需要委托一个线程去获取最新数据/对象，然后再更新本地缓存；
    如果后台线程多次更新失败，当前缓存数据/对象已经严重超时，即超过了 deprecated，此时应该丢弃当前缓存数据/对象，返回空数据/对象给调用者。

    模块设计

    首先我们设计一个 ```CacheHolder``` 类来保存被缓存数据/对象，以及与之对应的时间信息：

    1. import 'package:object_key/object_key.dart' show Time;
    2.  
    3.  
    4. /// Holder for cache value with times in seconds
    5. class CacheHolder <V> {
    6.   CacheHolder(V? cacheValue, double cacheLifeSpan, {double? now})
    7.       : _value = cacheValue, _life = cacheLifeSpan {
    8.     now ??= Time.currentTimestamp;
    9.     _expired = now + cacheLifeSpan;
    10.     _deprecated = now + cacheLifeSpan * 2;
    11.   }
    12.  
    13.   V? _value;
    14.  
    15.   final double _life;      // life span (in seconds)
    16.   double _expired = 0;     // time to expired
    17.   double _deprecated = 0;  // time to deprecated
    18.  
    19.   V? get value => _value;
    20.  
    21.   /// update cache value with current time in seconds
    22.   void update(V? newValue, {double? now}) {
    23.     _value = newValue;
    24.     now ??= Time.currentTimestamp;
    25.     _expired = now + _life;
    26.     _deprecated = now + _life * 2;
    27.   }
    28.  
    29.   /// check whether cache is alive with current time in seconds
    30.   bool isAlive({double? now}) {
    31.     now ??= Time.currentTimestamp;
    32.     return now < _expired;
    33.   }
    34.  
    35.   /// check whether cache is deprecated with current time in seconds
    36.   bool isDeprecated({double? now}) {
    37.     now ??= Time.currentTimestamp;
    38.     return now > _deprecated;
    39.   }
    40.  
    41.   /// renewal cache with a temporary life span and current time in seconds
    42.   void renewal(double? duration, {double? now}) {
    43.     duration ??= 120;
    44.     now ??= Time.currentTimestamp;
    45.     _expired = now + duration;
    46.     _deprecated = now + _life * 2;
    47.   }
    48.  
    49. }

    该类提供 update() 和 renew() 两个函数来更新缓存信息，前者为获取到最新数据之后调用以更新数据及时间，后者仅刷新一下时间，用以推迟有效时间；
    另外提供两个函数 isAlive() 和 isDeprecated()，分别用于判断是否需要更新，以及当前数据是否应该丢弃。

    另外，为使 CacheHolder 能适用于任意类型数据/对象，这里使用了“泛型”类型定义。

    缓存池

    接下来我们需要设计一个缓冲池 ```CachePool```，用于保存同类型的 ```CacheHolder```：

    1. import 'package:object_key/object_key.dart' show Time;
    2. import 'holder.dart';
    3.  
    4.  
    5. class CachePair <V> {
    6.   CachePair(this.value, this.holder);
    7.  
    8.   final V? value;
    9.   final CacheHolder holder;
    10.  
    11. }
    12.  
    13.  
    14. /// Pool for cache holders with keys
    15. class CachePool <K, V> {
    16.  
    17.   final Map> _holderMap = {};
    18.  
    19.   Iterable get keys => _holderMap.keys;
    20.  
    21.   /// update cache holder for key
    22.   CacheHolder update(K key, CacheHolder holder) {
    23.     _holderMap[key] = holder;
    24.     return holder;
    25.   }
    26.  
    27.   /// update cache value for key with timestamp in seconds
    28.   CacheHolder updateValue(K key, V? value, double life, {double? now}) =>
    29.       update(key, CacheHolder(value, life, now: now));
    30.  
    31.   /// erase cache for key
    32.   CachePair? erase(K key, {double? now}) {
    33.     CachePair? old;
    34.     if (now != null) {
    35.       // get exists value before erasing
    36.       old = fetch(key, now: now);
    37.     }
    38.     _holderMap.remove(key);
    39.     return old;
    40.   }
    41.  
    42.   /// fetch cache value & its holder
    43.   CachePair? fetch(K key, {double? now}) {
    44.     CacheHolder? holder = _holderMap[key];
    45.     if (holder == null) {
    46.       // holder not found
    47.       return null;
    48.     } else if (holder.isAlive(now: now)) {
    49.       return CachePair(holder.value, holder);
    50.     } else {
    51.       // holder expired
    52.       return CachePair(null, holder);
    53.     }
    54.   }
    55.  
    56.   /// clear expired cache holders
    57.   int purge({double? now}) {
    58.     now ??= Time.currentTimestamp;
    59.     int count = 0;
    60.     Iterable allKeys = keys;
    61.     CacheHolder? holder;
    62.     for (K key in allKeys) {
    63.       holder = _holderMap[key];
    64.       if (holder == null || holder.isDeprecated(now: now)) {
    65.         // remove expired holders
    66.         _holderMap.remove(key);
    67.         ++count;
    68.       }
    69.     }
    70.     return count;
    71.   }
    72.  
    73. }

    该缓冲池提供了 3 个接口给应用层使用：

    1. 更新缓存信息；
    2. 删除缓存信息；
    3. 获取缓存信息；

    另外还提供一个 purge() 函数给缓存管理器调用，以清除已失效的 CacheHolder。

    缓存管理器

    最后，我们还需要设计一个缓存管理器 ```CacheManager```，去统一管理所有不同类型的 ```CachePool```：

    1. import 'package:object_key/object_key.dart' show Time;
    2. import 'pool.dart';
    3.  
    4.  
    5. class CacheManager {
    6.   factory CacheManager() => _instance;
    7.   static final CacheManager _instance = CacheManager._internal();
    8.   CacheManager._internal();
    9.  
    10.   final Map<String, dynamic> _poolMap = {};
    11.  
    12.   ///  Get pool with name
    13.   ///
    14.   /// @param name - pool name
    15.   /// @param <K>  - key type
    16.   /// @param <V>  - value type
    17.   /// @return CachePool
    18.   CachePool getPool(String name) {
    19.     CachePool? pool = _poolMap[name];
    20.     if (pool == null) {
    21.       pool = CachePool();
    22.       _poolMap[name] = pool;
    23.     }
    24.     return pool;
    25.   }
    26.  
    27.   ///  Purge all pools
    28.   ///
    29.   /// @param now - current time
    30.   int purge(double? now) {
    31.     now ??= Time.currentTimestamp;
    32.     int count = 0;
    33.     CachePool? pool;
    34.     Iterable allKeys = _poolMap.keys;
    35.     for (var key in allKeys) {
    36.       pool = _poolMap[key];
    37.       if (pool != null) {
    38.         count += pool.purge(now: now);
    39.       }
    40.     }
    41.     return count;
    42.   }
    43.  
    44. }

    我们这个缓存管理包括两个接口：

    1. 一个工厂方法 getPool()，用于获取/创建缓存池；
    2. 一个清除接口 purge()，供系统在适当的时候（例如系统内存不足时）调用以释放缓存空间。

    至此，一个简单高效的本地缓存管理模块就写好了，下面我们来看看怎么用。

    应用示例

    假设我们有一个类 MetaTable，其作用是从数据库或者网络中获取 meta 信息，考虑到 I/O 的时间，以及数据解析为对象所消耗的 CPU 时间等，如果该类信息访问十分频繁，我们就需要为它加上一层缓存管理。

    先来看看代码：

    1.  
    2. class MetaTable implements MetaDBI {
    3.  
    4.   @override
    5.   Future getMeta(ID entity) async {
    6.     // 从数据库中获取 meta 信息
    7.   }
    8.  
    9.   @override
    10.   Future<bool> saveMeta(Meta meta, ID entity) async {
    11.     // 保存 meta 信息到数据库
    12.   }
    13.  
    14. }
    15.  
    16. class MetaCache extends MetaTable {
    17.  
    18.   final CachePool _cache = CacheManager().getPool('meta');
    19.  
    20.   @override
    21.   Future getMeta(ID entity) async {
    22.     CachePair? pair;
    23.     CacheHolder? holder;
    24.     Meta? value;
    25.     double now = Time.currentTimeSeconds;
    26.     await lock();
    27.     try {
    28.       // 1. check memory cache
    29.       pair = _cache.fetch(entity, now: now);
    30.       holder = pair?.holder;
    31.       value = pair?.value;
    32.       if (value == null) {
    33.         if (holder == null) {
    34.           // not load yet, wait to load
    35.         } else if (holder.isAlive(now: now)) {
    36.           // value not exists
    37.           return null;
    38.         } else {
    39.           // cache expired, wait to reload
    40.           holder.renewal(128, now: now);
    41.         }
    42.         // 2. load from database
    43.         value = await super.getMeta(entity);
    44.         // update cache
    45.         _cache.updateValue(entity, value, 36000, now: now);
    46.       }
    47.     } finally {
    48.       unlock();
    49.     }
    50.     // OK, return cache now
    51.     return value;
    52.   }
    53.  
    54.   @override
    55.   Future<bool> saveMeta(Meta meta, ID entity) async {
    56.     _cache.updateValue(entity, meta, 36000, now: Time.currentTimeSeconds);
    57.     return await super.saveMeta(meta, entity);
    58.   }
    59.  
    60. }

    带缓存读数据

    当需要读取数据时，先通过 ```_cache.fetch()``` 检查当前缓存池中是否存在有效的值：

    如果 (值存在)，则 {

        直接返回该值；

    }

    否则检查 holder；

    如果 (holder 存在且未过期)，则 {

        说明确实不存在该数据，返回空值；

    }

    否则调用父类接口获取最新数据；

    然后再更新本地缓存。

    带缓存写数据

    写数据就简单了，只需要在调用父类接口写数据库的同时刷新一下缓存即可。

    代码引用

    由于我已将这部分代码提交到了 pub.dev，所以在实际应用中，你只需要在项目工程文件 ```pubspec.yaml``` 中添加：

    dependencies:

        object_key: ^0.1.1

    然后在需要使用的 dart 文件头引入即可：

    import 'package:object_key/object_key.dart';

    全部源码

    1. /* license: https://mit-license.org
    2.  *
    3.  *  ObjectKey : Object & Key kits
    4.  *
    5.  *                               Written in 2023 by Moky 
    6.  *
    7.  * =============================================================================
    8.  * The MIT License (MIT)
    9.  *
    10.  * Copyright (c) 2023 Albert Moky
    11.  *
    12.  * Permission is hereby granted, free of charge, to any person obtaining a copy
    13.  * of this software and associated documentation files (the "Software"), to deal
    14.  * in the Software without restriction, including without limitation the rights
    15.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    16.  * copies of the Software, and to permit persons to whom the Software is
    17.  * furnished to do so, subject to the following conditions:
    18.  *
    19.  * The above copyright notice and this permission notice shall be included in all
    20.  * copies or substantial portions of the Software.
    21.  *
    22.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    23.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    24.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    25.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    26.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    27.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    28.  * SOFTWARE.
    29.  * =============================================================================
    30.  */
    31. import 'package:object_key/object_key.dart' show Time;
    32.  
    33.  
    34. /// Holder for cache value with times in seconds
    35. class CacheHolder <V> {
    36.   CacheHolder(V? cacheValue, double cacheLifeSpan, {double? now})
    37.       : _value = cacheValue, _life = cacheLifeSpan {
    38.     now ??= Time.currentTimestamp;
    39.     _expired = now + cacheLifeSpan;
    40.     _deprecated = now + cacheLifeSpan * 2;
    41.   }
    42.  
    43.   V? _value;
    44.  
    45.   final double _life;      // life span (in seconds)
    46.   double _expired = 0;     // time to expired
    47.   double _deprecated = 0;  // time to deprecated
    48.  
    49.   V? get value => _value;
    50.  
    51.   /// update cache value with current time in seconds
    52.   void update(V? newValue, {double? now}) {
    53.     _value = newValue;
    54.     now ??= Time.currentTimestamp;
    55.     _expired = now + _life;
    56.     _deprecated = now + _life * 2;
    57.   }
    58.  
    59.   /// check whether cache is alive with current time in seconds
    60.   bool isAlive({double? now}) {
    61.     now ??= Time.currentTimestamp;
    62.     return now < _expired;
    63.   }
    64.  
    65.   /// check whether cache is deprecated with current time in seconds
    66.   bool isDeprecated({double? now}) {
    67.     now ??= Time.currentTimestamp;
    68.     return now > _deprecated;
    69.   }
    70.  
    71.   /// renewal cache with a temporary life span and current time in seconds
    72.   void renewal(double? duration, {double? now}) {
    73.     duration ??= 120;
    74.     now ??= Time.currentTimestamp;
    75.     _expired = now + duration;
    76.     _deprecated = now + _life * 2;
    77.   }
    78.  
    79. }
    80.  
    81.  
    82. class CachePair <V> {
    83.   CachePair(this.value, this.holder);
    84.  
    85.   final V? value;
    86.   final CacheHolder holder;
    87.  
    88. }
    89.  
    90.  
    91. /// Pool for cache holders with keys
    92. class CachePool <K, V> {
    93.  
    94.   final Map> _holderMap = {};
    95.  
    96.   Iterable get keys => _holderMap.keys;
    97.  
    98.   /// update cache holder for key
    99.   CacheHolder update(K key, CacheHolder holder) {
    100.     _holderMap[key] = holder;
    101.     return holder;
    102.   }
    103.  
    104.   /// update cache value for key with timestamp in seconds
    105.   CacheHolder updateValue(K key, V? value, double life, {double? now}) =>
    106.       update(key, CacheHolder(value, life, now: now));
    107.  
    108.   /// erase cache for key
    109.   CachePair? erase(K key, {double? now}) {
    110.     CachePair? old;
    111.     if (now != null) {
    112.       // get exists value before erasing
    113.       old = fetch(key, now: now);
    114.     }
    115.     _holderMap.remove(key);
    116.     return old;
    117.   }
    118.  
    119.   /// fetch cache value & its holder
    120.   CachePair? fetch(K key, {double? now}) {
    121.     CacheHolder? holder = _holderMap[key];
    122.     if (holder == null) {
    123.       // holder not found
    124.       return null;
    125.     } else if (holder.isAlive(now: now)) {
    126.       return CachePair(holder.value, holder);
    127.     } else {
    128.       // holder expired
    129.       return CachePair(null, holder);
    130.     }
    131.   }
    132.  
    133.   /// clear expired cache holders
    134.   int purge({double? now}) {
    135.     now ??= Time.currentTimestamp;
    136.     int count = 0;
    137.     Iterable allKeys = keys;
    138.     CacheHolder? holder;
    139.     for (K key in allKeys) {
    140.       holder = _holderMap[key];
    141.       if (holder == null || holder.isDeprecated(now: now)) {
    142.         // remove expired holders
    143.         _holderMap.remove(key);
    144.         ++count;
    145.       }
    146.     }
    147.     return count;
    148.   }
    149.  
    150. }
    151.  
    152.  
    153. class CacheManager {
    154.   factory CacheManager() => _instance;
    155.   static final CacheManager _instance = CacheManager._internal();
    156.   CacheManager._internal();
    157.  
    158.   final Map<String, dynamic> _poolMap = {};
    159.  
    160.   ///  Get pool with name
    161.   ///
    162.   /// @param name - pool name
    163.   /// @param <K>  - key type
    164.   /// @param <V>  - value type
    165.   /// @return CachePool
    166.   CachePool getPool(String name) {
    167.     CachePool? pool = _poolMap[name];
    168.     if (pool == null) {
    169.       pool = CachePool();
    170.       _poolMap[name] = pool;
    171.     }
    172.     return pool;
    173.   }
    174.  
    175.   ///  Purge all pools
    176.   ///
    177.   /// @param now - current time
    178.   int purge(double? now) {
    179.     now ??= Time.currentTimestamp;
    180.     int count = 0;
    181.     CachePool? pool;
    182.     Iterable allKeys = _poolMap.keys;
    183.     for (var key in allKeys) {
    184.       pool = _poolMap[key];
    185.       if (pool != null) {
    186.         count += pool.purge(now: now);
    187.       }
    188.     }
    189.     return count;
    190.   }
    191.  
    192. }

    GitHub 地址：

    https://github.com/moky/ObjectKey/tree/main/object_key/lib/src/mem

    结语

    这里向大家展示了一个简单高效的本地缓存管理模块，该模块能有效避免重复创建相同对象，同时也可避免内存泄漏等问题。

    合理使用该模块，可以令你的应用程序访问数据的平均速度大幅提升，特别是在重复滚动展示大量数据的列表时，能让你的应用体验更加丝滑。

    如有其他问题，可以下载登录 Tarsier​​​​​​​ 与我交流（默认通讯录i找 Albert Moky）

  • 相关阅读:
    基于SSM的培训学校教学管理平台的设计与实现
    手把手教你使用LabVIEW人工智能视觉工具包快速实现图像读取与采集（含源码）
    【公司UI自动化学习】
    基于Matlab求解高教社杯全国大学生数学建模竞赛(CUMCM2012A题)-葡萄酒的评价（源码+数据）
    通过内网穿透技术实现USB设备共享（USB Redirector）逆向共享
    Leetcode hot 100
    【Go ~ 0到1 】 第七天 获取时间戳,时间比较,时间格式转换,Sleep与定时器
    LVGL 虚拟键盘使用
    “高级小程序开发指南“
    【来点小剧场--项目测试报告】个人博客项目自动化测试
  • 原文地址：https://blog.csdn.net/moky/article/details/139711545