函數語言程式設計-記憶化快取

記憶化，是一種為了提高應用程式效能的FP技術。程式加速是通過快取函式的結果實現的，避免了重複計算帶來的額外開銷。

1、現在我們使用Dictionary作為快取結構

public static Func<T, R> Memoize<T, R>(Func<T, R> func) 
    where T : IComparable
{
    Dictionary<T, R> cache = new Dictionary<T, R>();
    return arg =>
    {
        if (cache.ContainsKey(arg))
            return cache[arg];
        return (cache[arg] = func(arg));
    };
}

public static string GetString(string name)
{
    return $"return date {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} string {name}";
}

var getStrMemoize = Memoize<string, string>(GetString);
Console.WriteLine(getStrMemoize("A"));
Thread.Sleep(3000);
Console.WriteLine(getStrMemoize("B"));
Thread.Sleep(3000);
Console.WriteLine(getStrMemoize("A"));

列印結果：

return date 2020-12-31 08:37:12 string A
return date 2020-12-31 08:37:15 string B
return date 2020-12-31 08:37:12 string A

可以看出第三次列印的結果跟第一次列印的結果相同，也就是被快取在Dictionary中的值。

在單執行緒中我們這樣寫沒有問題，程式順序被執行，Dictionary不存在併發問題，但是當我們想在多個執行緒並行時Dictionary不是執行緒安全集合，會存線上程安全問題。

2、現在我們使用執行緒安全集合ConcurrentDictionary進行改進：（方法中註釋已經對方法做了說明，在此不重複）

/// <summary>
/// 使用執行緒安全集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="R"></typeparam>
/// <param name="func"></param>
/// 對於字典的修改和寫入操作， ConcurrentDictionary<TKey,TValue> 使用細粒度鎖定以確保執行緒安全。
/// 對字典進行 (讀取操作時，將以無鎖方式執行。) 不過，在 valueFactory 鎖的外部呼叫委託，以避免在鎖定下執行未知程式碼時可能產生的問題。
/// 因此，對於 GetOrAdd 類上的所有其他操作而言，不是原子的 ConcurrentDictionary<TKey,TValue> 。
/// 由於在生成值時，另一個執行緒可以插入鍵/值 valueFactory ，因此您不能信任這一點，
/// 因為已 valueFactory 執行，其生成的值將插入到字典中並返回。
/// 如果 GetOrAdd 在不同的執行緒上同時呼叫，則 valueFactory 可以多次呼叫，但只會將一個鍵/值對新增到字典中。
/// 返回值取決於字典中的鍵是否存在，以及是否在 GetOrAdd 呼叫之後但在生成值之前由另一個執行緒插入了鍵/值 valueFactory
/// (如果當前執行緒檢查到Key不在字典中，那麼會執行生成鍵值；但是在寫入前如果有執行緒完成了寫入鍵值，當前執行緒寫入前檢查到有寫入值，則以已寫入的為準)。
/// <returns></returns>
public static Func<T, R> MemoizeThreadSafe<T, R>(Func<T, R> func) where T : IComparable
{
    ConcurrentDictionary<T, R> cache = new ConcurrentDictionary<T, R>();
    return arg =>
    {
        return cache.GetOrAdd(arg, a => func(arg));
    };
}

var getStrMemoize = MemoizeThreadSafe<string, string>(GetString);
Console.WriteLine(getStrMemoize("A"));
Thread.Sleep(3000);
Console.WriteLine(getStrMemoize("B"));
Thread.Sleep(3000);
Console.WriteLine(getStrMemoize("A"));

列印結果：

return date 2020-12-31 08:42:46 string A
return date 2020-12-31 08:42:49 string B
return date 2020-12-31 08:42:46 string A

註解中我們說明了ConcurrentDictionary是執行緒安全集合，但是當我們使用GetOrAdd時，由於該方法不是原子性的操作，當進行初始化時，可能多個執行緒同時進行初始化操作，帶來了額外的開銷。

3、為解決GetOrAdd非原子性操作重複初始化操作，引入延遲初始化（註解已詳細說明）：

在看改進方法前我們先看下Lazy類的用法：

public class user
{
    public string name { get; set; }
}

Lazy<user> user = new Lazy<user>();
if (!user.IsValueCreated)
    Console.WriteLine("user 未建立.");
user.Value.name = "test";
if (user.IsValueCreated)
    Console.WriteLine("user 已建立.");

輸出：

user 未建立.
user 已建立.

以下為Lazy類程式碼片段，從程式碼我們看出在物件未使用（value）前，例項並未真正建立：

[NonSerialized]
private Func<T> m_valueFactory;

private object m_boxed;

public T Value
{
    get
    {
        return LazyInitValue();
    }
}
private T LazyInitValue()
{
    Boxed boxed = null;
    try
    {
        boxed = CreateValue();
        m_boxed = boxed;
    }
    finally
    {
    }
    return boxed.m_value;
}

private Boxed CreateValue()
{
    Boxed boxed = null;
    if (m_valueFactory != null) //() => func(arg)
    {
        try
        {
            Func<T> factory = m_valueFactory;

            boxed = new Boxed(factory());
        }
        catch (Exception ex)
        {
            throw;
        }
    }


    return boxed;
}

[Serializable]
class Boxed
{
    internal Boxed(T value)
    {
        m_value = value;
    }
    internal T m_value;
}

現在我們看下改進方法：

/// <summary>
/// 為解決GetOrAdd 非原子性操作，
/// 重複初始化操作，引入Lazy型別、
/// 延遲初始化
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="R"></typeparam>
/// <param name="func"></param>
/// 使用延遲初始化來延遲建立大型或消耗大量資源的物件，或者執行大量佔用資源的任務
/// ，尤其是在程式的生存期內可能不會發生這種建立或執行時。
/// 若要為遲緩初始化做好準備，請建立的例項 Lazy<T> 。
/// 你建立的物件的型別引數 Lazy<T> 指定你希望延遲初始化的物件的型別。
/// 用於建立物件的建構函式 Lazy<T> 確定初始化的特徵。
/// 首次訪問 Lazy<T>.Value 屬性時出現延遲初始化。
/// <returns></returns>
public static Func<T, R> MemoizeLazyThreadSafe<T, R>(Func<T, R> func) where T : IComparable
{
  ConcurrentDictionary<T, Lazy<R>> cache = new ConcurrentDictionary<T, Lazy<R>>();
  return arg =>
  {
      return cache.GetOrAdd(arg, a => new Lazy<R>(() => func(arg))).Value;
  };
}

到現在方法的執行緒安全、初始化載入問題都解決了，但是我們在解決重複計算的問題後卻又不得不考慮快取帶來的記憶體損耗問題。我們例項化了ConcurrentDictionary物件，並且該物件作為強引用型別一直未被釋放，那麼GC是無法回收該物件，帶來的問題是記憶體一直被佔用，隨著方法引用次數越來越多記憶體開銷則會越來越大。

4、為解決該問題，我們引入過期時間，根據過期時間釋放快取值。

public static Func<T, R> MemoizeWeakWithTtl<T, R>(Func<T, R> func, TimeSpan ttl)
    where T : class, IEquatable<T>
    where R : class
{
    var keyStore = new ConcurrentDictionary<int, T>();

    T ReduceKey(T obj)
    {
        var oldObj = keyStore.GetOrAdd(obj.GetHashCode(), obj);
        return obj.Equals(oldObj) ? oldObj : obj;
    }

    var cache = new ConditionalWeakTable<T, Tuple<R, DateTime>>();

    Tuple<R, DateTime> FactoryFunc(T key) =>
        new Tuple<R, DateTime>(func(key), DateTime.Now + ttl);

    return arg =>
    {
        var key = ReduceKey(arg);
        var value = cache.GetValue(key, FactoryFunc);
        if (value.Item2 >= DateTime.Now)
            return value.Item1;
        value = FactoryFunc(key);
        cache.Remove(key);
        cache.Add(key, value);
        return value.Item1;
    };
}

其他實現方式，使用WeakReference弱引用型別（以下為使用示例）：

public class Cache
{
    static Dictionary<int, WeakReference> _cache;

    int regenCount = 0;

    public Cache(int count)
    {
        _cache = new Dictionary<int, WeakReference>();

        for (int i = 0; i < count; i++)
        {
            _cache.Add(i, new WeakReference(new Data(i), false));
        }
    }

    public int Count
    {
        get { return _cache.Count; }
    }

    public int RegenerationCount
    {
        get { return regenCount; }
    }

    public Data this[int index]
    {
        get
        {
            Data d = _cache[index].Target as Data;
            if (d == null)
            {
                Console.WriteLine("Regenerate object at {0}: Yes", index);
                d = new Data(index);
                _cache[index].Target = d;
                regenCount++;
            }
            else
            {
                Console.WriteLine("Regenerate object at {0}: No", index);
            }

            return d;
        }
    }
}


public class Data
{
    private byte[] _data;
    private string _name;

    public Data(int size)
    {
        _data = new byte[size * 1024];
        _name = size.ToString();
    }

    // Simple property.
    public string Name
    {
        get { return _name; }
    }
}

int cacheSize = 50;
Random r = new Random();
Cache c = new Cache(cacheSize);

string DataName = "";
GC.Collect(0);

for (int i = 0; i < c.Count; i++)
{
    int index = r.Next(c.Count);
    DataName = c[index].Name;
}
double regenPercent = c.RegenerationCount / (double)c.Count;
Console.WriteLine("Cache size: {0}, Regenerated: {1:P2}%", c.Count, regenPercent);

列印結果：

Regenerate object at 46: Yes
Regenerate object at 5: Yes
Regenerate object at 6: Yes
Regenerate object at 31: Yes
Regenerate object at 1: Yes
Regenerate object at 33: Yes
Regenerate object at 11: Yes
Regenerate object at 5: No
Regenerate object at 37: Yes
Regenerate object at 15: Yes
Regenerate object at 25: Yes
Regenerate object at 14: No
Regenerate object at 16: Yes
Regenerate object at 20: Yes
Regenerate object at 10: Yes
Regenerate object at 14: No
Regenerate object at 17: Yes
Regenerate object at 28: Yes
Regenerate object at 7: Yes
Regenerate object at 34: Yes
Regenerate object at 45: Yes
Regenerate object at 33: No
Regenerate object at 29: Yes
Regenerate object at 32: Yes
Regenerate object at 32: No
Regenerate object at 4: No
Regenerate object at 42: Yes
Regenerate object at 6: No
Regenerate object at 16: No
Regenerate object at 36: Yes
Regenerate object at 12: Yes
Regenerate object at 9: Yes
Regenerate object at 43: Yes
Regenerate object at 12: No
Regenerate object at 49: Yes
Regenerate object at 37: No
Regenerate object at 36: No
Regenerate object at 44: Yes
Regenerate object at 22: Yes
Regenerate object at 31: No
Regenerate object at 1: No
Regenerate object at 24: No
Regenerate object at 23: Yes
Regenerate object at 38: Yes
Regenerate object at 6: No
Regenerate object at 31: No
Regenerate object at 28: No
Cache size: 50, Regenerated: 66.00%%

具體實現方式不在此實現。