MemoryCache-Thread-Sicherheit, ist eine Sperrung erforderlich?

Lassen Sie mich zunächst einmal wissen, dass der folgende Code nicht threadsicher ist (Korrektur: möglicherweise). Ich habe Probleme damit, eine Implementierung zu finden, die tatsächlich getestet werden kann. Ich überarbeite gerade ein großes WCF-Projekt, für das einige (meistens) statische Daten zwischengespeichert und aus einer SQL-Datenbank ausgefüllt werden müssen. Es muss mindestens einmal am Tag ablaufen und "aktualisiert" werden, weshalb ich MemoryCache verwende.

Ich weiß, dass der folgende Code nicht threadsicher sein sollte, aber ich kann nicht erreichen, dass er unter hoher Last fehlschlägt und um die Sache zu komplizieren. Eine Google-Suche zeigt Implementierungen in beide Richtungen (mit und ohne Sperren kombiniert mit Debatten, ob sie notwendig sind oder nicht).

Könnte jemand mit Kenntnissen über MemoryCache in einer Umgebung mit mehreren Threads mich definitiv wissen lassen, ob ich gegebenenfalls sperren muss, damit ein zu entfernender Aufruf (der selten aufgerufen wird, aber erforderlich ist) beim Abrufen / erneuten Auffüllen nicht ausgelöst wird.

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;
    }
}

Die standardmäßige MS-Bereitstellung MemoryCacheist vollständig threadsicher. Eine benutzerdefinierte Implementierung, von der abgeleitet wird, ist MemoryCachemöglicherweise nicht threadsicher. Wenn Sie " MemoryCacheout of the box" verwenden, ist es threadsicher. Durchsuchen Sie den Quellcode meiner Open Source Distributed Caching-Lösung, um zu sehen, wie ich sie verwende (MemCache.cs):

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

Während MemoryCache in der Tat threadsicher ist, wie andere Antworten angegeben haben, gibt es ein häufiges Problem mit mehreren Threads. Wenn zwei Threads gleichzeitig versuchen, den Cache zu verlassen Get(oder zu überprüfen Contains), verfehlen beide den Cache und beide generieren am Ende Das Ergebnis und beide fügen das Ergebnis dann dem Cache hinzu.

Oft ist dies unerwünscht - der zweite Thread sollte warten, bis der erste abgeschlossen ist, und sein Ergebnis verwenden, anstatt zweimal Ergebnisse zu generieren.

Dies war einer der Gründe, warum ich LazyCache geschrieben habe - einen benutzerfreundlichen Wrapper für MemoryCache, der diese Art von Problemen löst. Es ist auch auf Nuget erhältlich .

Wie bereits erwähnt, ist MemoryCache in der Tat threadsicher. Die Thread-Sicherheit der darin gespeicherten Daten hängt jedoch ganz von Ihrer Verwendung ab.

Um Reed Copsey aus seinem großartigen Beitrag über Parallelität und den ConcurrentDictionary<TKey, TValue>Typ zu zitieren . Welches ist natürlich hier anwendbar.

Wenn zwei Threads dies gleichzeitig [GetOrAdd] aufrufen, können problemlos zwei Instanzen von TValue erstellt werden.

Sie können sich vorstellen, dass dies besonders schlimm wäre, wenn TValueder Bau teuer wäre.

Um dies zu umgehen, können Sie es Lazy<T>sehr einfach nutzen, was zufällig sehr billig zu konstruieren ist. Auf diese Weise stellen wir sicher, dass wir nur mehrere Instanzen von Lazy<T>(was billig ist) erstellen, wenn wir in eine Multithread-Situation geraten .

GetOrAdd()( GetOrCreate()im Fall von MemoryCache) gibt den gleichen Singular Lazy<T>für alle Threads zurück, die "zusätzlichen" Instanzen von Lazy<T>werden einfach weggeworfen.

Da das Lazy<T>nichts tut, bis .Valuees aufgerufen wird, wird immer nur eine Instanz des Objekts erstellt.

Nun zu etwas Code! Unten finden Sie eine Erweiterungsmethode, für IMemoryCachedie die oben genannten implementiert werden. Die Einstellung SlidingExpirationbasiert willkürlich auf einem int secondsMethodenparameter. Dies ist jedoch vollständig an Ihre Bedürfnisse anpassbar.

Beachten Sie, dass dies spezifisch für .netcore2.0-Apps ist

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);
}

Anrufen:

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

Um dies alles asynchron durchzuführen, empfehle ich die Verwendung der hervorragenden AsyncLazy<T>Implementierung von Stephen Toub, die in seinem Artikel über MSDN zu finden ist. Was den eingebauten Lazy Initialisierer Lazy<T>mit dem Versprechen kombiniert 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())
    { }
}   

Jetzt die asynchrone Version von 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);
}

Und zum Schluss:

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

Überprüfen Sie diesen Link: http://msdn.microsoft.com/en-us/library/system.runtime.caching.memorycache(v=vs.110).aspx

Gehen Sie ganz nach unten auf der Seite (oder suchen Sie nach dem Text "Thread Safety").

Du wirst sehen:

^ Gewindesicherheit

Dieser Typ ist threadsicher.

Sie haben gerade eine Beispielbibliothek hochgeladen, um das Problem für .Net 2.0 zu beheben.

Schauen Sie sich dieses Repo an:

RedisLazyCache

Ich verwende den Redis-Cache, aber es ist auch ein Failover oder nur ein Memorycache, wenn der Verbindungsstring fehlt.

Es basiert auf der LazyCache-Bibliothek, die die einmalige Ausführung eines Rückrufs zum Schreiben im Falle eines Multithreading garantiert, bei dem versucht wird, Daten zu laden und zu speichern, insbesondere wenn die Ausführung des Rückrufs sehr teuer ist.

Wie von @AmitE bei der Antwort von @pimbrouwers erwähnt, funktioniert sein Beispiel nicht wie hier gezeigt:

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;
    }
}

Ausgabe:

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

Es scheint, als würde GetOrCreateimmer der erstellte Eintrag zurückgegeben. Zum Glück ist das sehr einfach zu beheben:

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;
}

Das funktioniert wie erwartet:

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

Der Cache ist threadsicher, aber wie andere angegeben haben, ist es möglich, dass GetOrAdd die Funktion mehrere Typen aufruft, wenn mehrere Typen aufgerufen werden.

Hier ist meine minimale Lösung dafür

private readonly SemaphoreSlim _cacheLock = new SemaphoreSlim(1);

und

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