真正的懶惰緩存模式？ F＃

Question

我有以下類型實現一個簡單的懶惰高速緩存：

module CachedFoo = 

let mutable private lastAccess:Option<DateTime> = None 

// returns a lazy value that initializes the cache when 
// accessed for the first time (safely) 
let private createCacheInitialization() = 
    lazy(
     let someObject = SomeLongRunningOperation() 
     lastAccess <- Option.Some(DateTime.Now) 
     someObject 
    ) 

// current cache represented as lazy value 
let mutable private currentCache = createCacheInitialization() 

// Reset - cache will be re-initialized next time it is accessed 
// (this doesn't actually initialize a cache - just creates a lazy value) 
let MaybeReset() = 
    if (lastAccess.IsSome && DateTime.Now > (lastAccess.Value + TimeSpan.FromSeconds (10.0))) then 
     currentCache <- createCacheInitialization() 

let GetCache() = 
    MaybeReset() 
    currentCache.Value 

第一個問題：是上述線程安全的？看起來lazy（）默認是線程安全的，但我想我需要在lastAccess字段的賦值處加上一些鎖定。

其次，最重要的是：這是它的值沒有檢索到它的人需要的感覺懶散，不過，我想我甚至可以做到這一點比較懶惰通過即使在復位的情況下返回最後緩存的對象（）被調用，但在後臺啓動一個異步線程來調用這個方法。

在C＃中它會是這樣的：

public SomeObject GetCache() { 
    try { 
     return currentCache.Value; 
    } finally { 
     ThreadPool.QueueUserWorkItem(new WaitCallback(MaybeReset)); 
    } 
} 

我會怎麼做，在F＃？ （如果解決方案使用花哨的異步的東西而不是使用ThreadPool API，獎勵點）。

Answer 1

由於Ganesh的洞察力，我終於來到了這個解決方案並不能使第二個請求的結果等待，而它的被刷新：

module CachedFoo = 

let mutable private lastAccess:Option<DateTime> = None 

// returns a lazy value that initializes the cache when 
// accessed for the first time (safely) 
let private createCacheInitialization() = 
    lazy(
     let someObject = SomeLongRunningOperation() 
     lastAccess <- Option.Some(DateTime.Now) 
     someObject 
    ) 

// current cache represented as lazy value 
let mutable private currentCache = createCacheInitialization() 

let lockObject = new Object() 

let timeout = TimeSpan.FromSeconds (10.0) 

// Reset - cache will be re-initialized next time it is accessed 
// (this doesn't actually initialize a cache - just creates a lazy value) 
let MaybeReset() = 
    lock lockObject (fun() -> 
     if (lastAccess.IsSome && DateTime.Now > (lastAccess.Value + timeout)) then 
      let newCache = createCacheInitialization() 
      ignore(newCache.Force()) 
      currentCache <- newCache 
    ) 

let GetCache() = 
    let v = currentCache.Value // to make sure we get the old one 
    async { MaybeReset() } |> Async.Start 
    v 

Answer 2

我想更新lastAccess是線程安全的，原因有二

• 你只有做到這一點lazy這意味着它一定會無論如何都要更新一次（雖然有可能是一個更微妙的比賽裏面Reset，我不能確定）

• lastAccess是一個單一的引用（Option）等將原子反正更新

揭開序幕新的「發射後不管」 async重新計算的值，做這樣的事情：

let GetCache() = 
    let v = currentCache.Value // to make sure we get the old one 
    async { MaybeReset() } |> Async.Start 
    v