MemoryCacheスレッドセーフ、ロックは必要ですか？

手始めに、以下のコードはスレッドセーフではないことがわかっているので、それを捨てさせてください（修正：そうかもしれません）。私が苦労しているのは、テストで実際に失敗する可能性のある実装を見つけることです。現在、大規模なWCFプロジェクトをリファクタリングしています。このプロジェクトでは、（ほとんどの場合）静的データをキャッシュし、SQLデータベースからデータを取り込む必要があります。少なくとも1日に1回は有効期限が切れて「更新」する必要があるため、MemoryCacheを使用しています。

以下のコードはスレッドセーフであってはならないことは知っていますが、高負荷で失敗することはなく、問題を複雑にするために、グーグル検索は両方の方法で実装を示しています（ロックの有無と必要かどうかの議論が組み合わされています。

マルチスレッド環境でのMemoryCacheの知識がある人は、削除の呼び出し（めったに呼び出されませんが、その要件）が取得/再入力中にスローされないように、必要に応じてロックする必要があるかどうかを明確に教えてくれますか？

public class MemoryCacheService : IMemoryCacheService
{
    private const string PunctuationMapCacheKey = "punctuationMaps";
    private static readonly ObjectCache Cache;
    private readonly IAdoNet _adoNet;

    static MemoryCacheService()
    {
        Cache = MemoryCache.Default;
    }

    public MemoryCacheService(IAdoNet adoNet)
    {
        _adoNet = adoNet;
    }

    public void ClearPunctuationMaps()
    {
        Cache.Remove(PunctuationMapCacheKey);
    }

    public IEnumerable GetPunctuationMaps()
    {
        if (Cache.Contains(PunctuationMapCacheKey))
        {
            return (IEnumerable) Cache.Get(PunctuationMapCacheKey);
        }

        var punctuationMaps = GetPunctuationMappings();

        if (punctuationMaps == null)
        {
            throw new ApplicationException("Unable to retrieve punctuation mappings from the database.");
        }

        if (punctuationMaps.Cast<IPunctuationMapDto>().Any(p => p.UntaggedValue == null || p.TaggedValue == null))
        {
            throw new ApplicationException("Null values detected in Untagged or Tagged punctuation mappings.");
        }

        // Store data in the cache
        var cacheItemPolicy = new CacheItemPolicy
        {
            AbsoluteExpiration = DateTime.Now.AddDays(1.0)
        };

        Cache.AddOrGetExisting(PunctuationMapCacheKey, punctuationMaps, cacheItemPolicy);

        return punctuationMaps;
    }

    //Go oldschool ADO.NET to break the dependency on the entity framework and need to inject the database handler to populate cache
    private IEnumerable GetPunctuationMappings()
    {
        var table = _adoNet.ExecuteSelectCommand("SELECT [id], [TaggedValue],[UntaggedValue] FROM [dbo].[PunctuationMapper]", CommandType.Text);
        if (table != null && table.Rows.Count != 0)
        {
            return AutoMapper.Mapper.DynamicMap<IDataReader, IEnumerable<PunctuationMapDto>>(table.CreateDataReader());
        }

        return null;
    }
}

デフォルトのMS提供MemoryCacheは、完全にスレッドセーフです。から派生したカスタム実装は、MemoryCacheスレッドセーフではない可能性があります。MemoryCache箱から出してプレーンを使用している場合は、スレッドセーフです。オープンソースの分散キャッシングソリューションのソースコードを参照して、その使用方法を確認します（MemCache.cs）。

https://github.com/haneytron/dache/blob/master/Dache.CacheHost/Storage/MemCache.cs

他の回答が指定しているように、MemoryCacheは確かにスレッドセーフですが、一般的なマルチスレッドの問題があります-2つのスレッドが同時にキャッシュGetから取得（またはチェックContains）しようとすると、両方がキャッシュを見逃し、両方が生成されます結果と両方が結果をキャッシュに追加します。

多くの場合、これは望ましくありません。2番目のスレッドは、結果を2回生成するのではなく、最初のスレッドが完了するのを待ってその結果を使用する必要があります。

これが、私がLazyCacheを作成した理由の1つです。これは、この種の問題を解決するMemoryCacheの使いやすいラッパーです。Nugetでも利用できます。

他の人が述べているように、MemoryCacheは確かにスレッドセーフです。ただし、その中に格納されているデータのスレッドセーフは、完全に使用者次第です。

並行性とタイプに関する彼の素晴らしい投稿からReedCopseyを引用します。もちろん、これはここに当てはまります。ConcurrentDictionary<TKey, TValue>

2つのスレッドがこれを同時に[GetOrAdd]と呼ぶ場合、TValueの2つのインスタンスを簡単に構築できます。

TValue構築に費用がかかる場合、これは特に悪いことになると想像できます。

これを回避するためLazy<T>に、非常に簡単に活用できます。これは偶然にも非常に安価に構築できます。これを行うことで、マルチスレッドの状況に陥った場合に、Lazy<T>（安価な）の複数のインスタンスのみを構築していることが保証されます。

GetOrAdd()（GetOrCreate()の場合MemoryCache）は、Lazy<T>すべてのスレッドに同じ、特異なものを返します。の「余分な」インスタンスLazy<T>は単に破棄されます。

が呼び出されるLazy<T>まで.Valueは何も実行しないため、オブジェクトのインスタンスは1つだけ作成されます。

今、いくつかのコードのために！以下はIMemoryCache、上記を実装する拡張メソッドです。メソッドパラメータにSlidingExpiration基づいて任意に設定していint secondsます。しかし、これはあなたのニーズに基づいて完全にカスタマイズ可能です。

これは.netcore2.0アプリに固有であることに注意してください

public static T GetOrAdd<T>(this IMemoryCache cache, string key, int seconds, Func<T> factory)
{
    return cache.GetOrCreate<T>(key, entry => new Lazy<T>(() =>
    {
        entry.SlidingExpiration = TimeSpan.FromSeconds(seconds);

        return factory.Invoke();
    }).Value);
}

電話するには：

IMemoryCache cache;
var result = cache.GetOrAdd("someKey", 60, () => new object());

これをすべて非同期で実行するには、MSDNの記事にあるStephenToubの優れたAsyncLazy<T>実装を使用することをお勧めします。これは、組み込みの遅延初期化子とpromiseを組み合わせたものです。Lazy<T>Task<T>

public class AsyncLazy<T> : Lazy<Task<T>>
{
    public AsyncLazy(Func<T> valueFactory) :
        base(() => Task.Factory.StartNew(valueFactory))
    { }
    public AsyncLazy(Func<Task<T>> taskFactory) :
        base(() => Task.Factory.StartNew(() => taskFactory()).Unwrap())
    { }
}   

今の非同期バージョンGetOrAdd()：

public static Task<T> GetOrAddAsync<T>(this IMemoryCache cache, string key, int seconds, Func<Task<T>> taskFactory)
{
    return cache.GetOrCreateAsync<T>(key, async entry => await new AsyncLazy<T>(async () =>
    { 
        entry.SlidingExpiration = TimeSpan.FromSeconds(seconds);

        return await taskFactory.Invoke();
    }).Value);
}

そして最後に、電話する：

IMemoryCache cache;
var result = await cache.GetOrAddAsync("someKey", 60, async () => new object());

このリンクを確認してください：http：//msdn.microsoft.com/en-us/library/system.runtime.caching.memorycache（v = vs.110）.aspx

ページの一番下に移動します（または「スレッドセーフ」というテキストを検索します）。

次のように表示されます。

^スレッドセーフ

このタイプはスレッドセーフです。

.Net 2.0の問題に対処するために、サンプルライブラリをアップロードしました。

このリポジトリを見てください：

RedisLazyCache

Redisキャッシュを使用していますが、接続文字列がない場合はフェイルオーバーまたはメモリキャッシュのみを使用しています。

これはLazyCacheライブラリに基づいており、コールバックの実行に非常にコストがかかる場合に、マルチスレッドがデータをロードおよび保存しようとした場合に、書き込み用のコールバックの単一実行を保証します。

@pimbrouwersの回答で@AmitEが述べたように、彼の例はここに示されているように機能していません。

class Program
{
    static async Task Main(string[] args)
    {
        var cache = new MemoryCache(new MemoryCacheOptions());

        var tasks = new List<Task>();
        var counter = 0;

        for (int i = 0; i < 10; i++)
        {
            var loc = i;
            tasks.Add(Task.Run(() =>
            {
                var x = GetOrAdd(cache, "test", TimeSpan.FromMinutes(1), () => Interlocked.Increment(ref counter));
                Console.WriteLine($"Interation {loc} got {x}");
            }));
        }

        await Task.WhenAll(tasks);
        Console.WriteLine("Total value creations: " + counter);
        Console.ReadKey();
    }

    public static T GetOrAdd<T>(IMemoryCache cache, string key, TimeSpan expiration, Func<T> valueFactory)
    {
        return cache.GetOrCreate(key, entry =>
        {
            entry.SetSlidingExpiration(expiration);
            return new Lazy<T>(valueFactory, LazyThreadSafetyMode.ExecutionAndPublication);
        }).Value;
    }
}

出力：

Interation 6 got 8
Interation 7 got 6
Interation 2 got 3
Interation 3 got 2
Interation 4 got 10
Interation 8 got 9
Interation 5 got 4
Interation 9 got 1
Interation 1 got 5
Interation 0 got 7
Total value creations: 10

GetOrCreate常に作成されたエントリを返すようです。幸いなことに、これは非常に簡単に修正できます。

public static T GetOrSetValueSafe<T>(IMemoryCache cache, string key, TimeSpan expiration,
    Func<T> valueFactory)
{
    if (cache.TryGetValue(key, out Lazy<T> cachedValue))
        return cachedValue.Value;

    cache.GetOrCreate(key, entry =>
    {
        entry.SetSlidingExpiration(expiration);
        return new Lazy<T>(valueFactory, LazyThreadSafetyMode.ExecutionAndPublication);
    });

    return cache.Get<Lazy<T>>(key).Value;
}

それは期待どおりに機能します：

Interation 4 got 1
Interation 9 got 1
Interation 1 got 1
Interation 8 got 1
Interation 0 got 1
Interation 6 got 1
Interation 7 got 1
Interation 2 got 1
Interation 5 got 1
Interation 3 got 1
Total value creations: 1

キャッシュはスレッドセーフですが、他の人が述べているように、複数のタイプから呼び出す場合、GetOrAddがfuncを複数のタイプで呼び出す可能性があります。

これが私の最小限の修正です

private readonly SemaphoreSlim _cacheLock = new SemaphoreSlim(1);

そして

await _cacheLock.WaitAsync();
var data = await _cache.GetOrCreateAsync(key, entry => ...);
_cacheLock.Release();