MemoryCache İş Parçacığı Güvenliği, Kilitlemek Gerekli mi?

Yeni başlayanlar için, aşağıdaki kodun iş parçacığı için güvenli olmadığını bildiğimi oraya atmama izin verin (düzeltme: olabilir). Mücadele ettiğim şey, gerçekten test altında başarısız olabileceğim bir uygulama bulmak. Şu anda bazı (çoğunlukla) statik verilerin önbelleğe alınması ve bir SQL veritabanından doldurulması gereken büyük bir WCF projesini yeniden oluşturuyorum. Günde en az bir kez süresinin dolması ve "yenilenmesi" gerekiyor, bu yüzden MemoryCache kullanıyorum.

Aşağıdaki kodun iş parçacığı açısından güvenli olmaması gerektiğini biliyorum, ancak ağır yük altında başarısız olmasını ve sorunları karmaşıklaştırmasını sağlayamıyorum, bir google arama uygulamaları her iki şekilde de gösterir (kilitli ve kilitsiz, gerekli olup olmadıkları tartışmalarla birlikte.

Çok iş parçacıklı bir ortamda MemoryCache bilgisine sahip biri, geri alma / yeniden doldurma sırasında kaldırılacak bir çağrının (nadiren çağrılacak, ancak bir gerekliliktir) atılmaması için uygun olduğunda kilitlemem gerekip gerekmediğini kesin olarak bana söyleyebilir mi?

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

Varsayılan MS tarafından sağlanan MemoryCache, tamamen iş parçacığı güvenlidir. Kaynaklanan herhangi bir özel uygulama MemoryCacheiş parçacığı açısından güvenli olmayabilir. MemoryCacheKutudan çıkar çıkmaz kullanıyorsanız , iş parçacığı için güvenlidir. Nasıl kullandığımı görmek için açık kaynak dağıtılmış önbellekleme çözümümün kaynak koduna göz atın (MemCache.cs):

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

MemoryCache gerçekten diğer yanıtların belirttiği gibi iş parçacığı açısından güvenli olsa da, ortak bir çoklu iş parçacığı sorununa sahiptir - eğer 2 iş parçacığı aynı anda önbelleği denerse Get(veya kontrol ederse Contains), o zaman her ikisi de önbelleği kaçırır ve her ikisi de üretilir. sonuç ve her ikisi de sonucu önbelleğe ekler.

Çoğu zaman bu istenmeyen bir durumdur - ikinci iş parçacığı, iki kez sonuç oluşturmak yerine ilkinin sonucunu tamamlamasını ve kullanmasını beklemelidir.

Bu, MemoryCache üzerinde bu tür sorunları çözen kullanışlı bir paketleyici olan LazyCache yazmamın nedenlerinden biriydi . Ayrıca Nuget'te de mevcuttur .

Diğerlerinin de belirttiği gibi, MemoryCache gerçekten iş parçacığı için güvenlidir. Bununla birlikte, içinde depolanan verilerin iş parçacığı güvenliği tamamen sizin kullanımınıza bağlıdır.

Reed Copsey'den eşzamanlılık ve türle ilgili harika gönderisinden alıntı yapmak için ConcurrentDictionary<TKey, TValue>. Elbette burada geçerli olan.

İki iş parçacığı bunu aynı anda [GetOrAdd] olarak çağırırsa, iki TValue örneği kolayca oluşturulabilir.

TValueİnşa edilmesi pahalıysa, bunun özellikle kötü olacağını hayal edebilirsiniz .

Bunun üstesinden Lazy<T>gelmek için, çok kolay bir şekilde yararlanabilirsiniz , bu tesadüfen inşa etmek çok ucuzdur. Bunu yapmak, çok iş parçacıklı bir duruma girersek, bunun yalnızca birden çok örneğini oluşturmamızı sağlar Lazy<T>(ucuzdur).

GetOrAdd()( GetOrCreate()olması durumunda MemoryCache) Lazy<T>tüm iş parçacıklarına tekil olarak aynı şeyi döndürecektir , "ekstra" örnekleri Lazy<T>basitçe atılır.

Yana Lazy<T>kadar bir şey yapmaz .Valuedenir, nesnenin yalnızca bir örneği şimdiye inşa edilmiştir.

Şimdi biraz kod için! Aşağıda, IMemoryCacheyukarıdakileri uygulayan bir genişletme yöntemi bulunmaktadır . İsteğe SlidingExpirationbağlı olarak bir int secondsyöntem parametresine göre ayarlanıyor . Ancak bu, ihtiyaçlarınıza göre tamamen özelleştirilebilir.

Bunun .netcore2.0 uygulamalarına özgü olduğunu unutmayın

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

Aramak:

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

Tüm bunları eşzamansız olarak gerçekleştirmek için, Stephen Toub'un MSDN hakkındaki makalesindeAsyncLazy<T> bulunan mükemmel uygulamasını kullanmanızı öneririm . Tembel başlatıcısı yerleşik hangi birleştirir vaadiyle :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())
    { }
}   

Şimdi şunun eşzamansız sürümü 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);
}

Ve son olarak aramak için:

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

Bu bağlantıya göz atın: http://msdn.microsoft.com/en-us/library/system.runtime.caching.memorycache(v=vs.110).aspx

Sayfanın en altına gidin (veya "İş Parçacığı Güvenliği" metnini arayın).

Göreceksin:

^ İplik Güvenliği

Bu tür iş parçacığı açısından güvenlidir.

.Net 2.0 sorununu çözmek için örnek kitaplık yükledim.

Bu depoya bir göz atın:

RedisLazyCache

Redis önbelleğini kullanıyorum, ancak Bağlantı dizesi eksikse yük devretme veya yalnızca Bellek Önbelleği kullanıyorum.

Geri aramanın yürütülmesi çok pahalıysa, özel olarak veri yüklemeye ve kaydetmeye çalışan bir çoklu iş parçacığı durumunda yazma için tek bir geri aramanın yürütülmesini garanti eden LazyCache kitaplığına dayanır.

@AmitE tarafından @pimbrouwers'ın yanıtında belirtildiği gibi, örneği burada gösterildiği gibi çalışmıyor:

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

Çıktı:

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

Her GetOrCreatezaman oluşturulan girdiyi döndürüyor gibi görünüyor . Neyse ki, düzeltmesi çok kolay:

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

Beklendiği gibi çalışıyor:

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

Önbellek iş parçacığı güvenlidir, ancak diğerlerinin de belirttiği gibi, GetOrAdd'ın birden çok türden çağrı varsa func birden çok türü çağırması mümkündür.

İşte bu konuda minimum düzeltmem

private readonly SemaphoreSlim _cacheLock = new SemaphoreSlim(1);

ve

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