ความปลอดภัยของเธรด MemoryCache จำเป็นต้องล็อคหรือไม่?

สำหรับผู้เริ่มต้นให้ฉันโยนมันออกไปที่นั่นฉันรู้ว่ารหัสด้านล่างไม่ปลอดภัยสำหรับเธรด (การแก้ไข: อาจจะ) สิ่งที่ฉันกำลังดิ้นรนคือการค้นหาการใช้งานที่เป็นจริงและเป็นสิ่งที่ฉันสามารถทำได้จริงภายใต้การทดสอบ ฉันกำลังปรับโครงสร้างโครงการ WCF ขนาดใหญ่ในขณะนี้ที่ต้องการข้อมูลแบบคงที่ (ส่วนใหญ่) แคชและสร้างจากฐานข้อมูล SQL จำเป็นต้องหมดอายุและ "รีเฟรช" อย่างน้อยวันละครั้งซึ่งเป็นสาเหตุที่ฉันใช้ MemoryCache

ฉันรู้ว่ารหัสด้านล่างไม่ควรเป็นเธรดที่ปลอดภัย แต่ฉันไม่สามารถทำให้มันล้มเหลวภายใต้ภาระงานหนักและทำให้เรื่องซับซ้อนขึ้นการค้นหาของ Google จะแสดงการใช้งานทั้งสองวิธี (มีและไม่มีการล็อกรวมกับการอภิปรายว่าจำเป็นหรือไม่

ใครบางคนที่มีความรู้เกี่ยวกับ 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) แคชในเวลาเดียวกันทั้งสองจะพลาดแคชและทั้งสองจะสิ้นสุดการสร้าง ผลลัพธ์และทั้งสองจะเพิ่มผลลัพธ์ลงในแคช

บ่อยครั้งสิ่งนี้ไม่เป็นที่ต้องการ - เธรดที่สองควรรอให้เธรดแรกเสร็จสมบูรณ์และใช้ผลลัพธ์แทนที่จะสร้างผลลัพธ์สองครั้ง

นี่เป็นหนึ่งในเหตุผลที่ฉันเขียน LazyCacheซึ่งเป็นกระดาษห่อหุ้มที่เป็นมิตรบน MemoryCache ซึ่งช่วยแก้ปัญหาต่างๆเหล่านี้ได้ มันก็ยังมีอยู่Nuget

ตามที่คนอื่น ๆ ระบุไว้ MemoryCache นั้นปลอดภัยแน่นอน อย่างไรก็ตามความปลอดภัยของเธรดของข้อมูลที่จัดเก็บอยู่ภายในนั้นขึ้นอยู่กับการใช้งานของคุณ

เพื่ออ้างถึงReed Copseyจากโพสต์ที่ยอดเยี่ยมของเขาเกี่ยวกับการทำงานพร้อมกันและConcurrentDictionary<TKey, TValue>ประเภท ซึ่งใช้ได้แน่นอนที่นี่

หากสองเธรดเรียกสิ่งนี้ว่า [GetOrAdd] พร้อมกันจะสามารถสร้าง TValue สองอินสแตนซ์ได้อย่างง่ายดาย

คุณสามารถจินตนาการได้ว่าสิ่งนี้จะแย่มากถ้า TValueมีราคาแพงในการสร้าง

ในการแก้ไขปัญหานี้คุณสามารถใช้ประโยชน์Lazy<T>ได้ง่ายมากซึ่งบังเอิญมีราคาถูกมากในการสร้าง การทำเช่นนี้ช่วยให้มั่นใจได้ว่าเราตกอยู่ในสถานการณ์มัลติเธรดหรือไม่เรากำลังสร้างอินสแตนซ์หลาย ๆ อินสแตนซ์Lazy<T>(ซึ่งมีราคาถูก) เท่านั้น

GetOrAdd()( GetOrCreate()ในกรณีของMemoryCache) จะส่งคืนค่าเดียวกันเป็นเอกพจน์Lazy<T>สำหรับทุกเธรดอินสแตนซ์ "พิเศษ" ของLazy<T>จะถูกโยนทิ้งไป

เนื่องจากLazy<T>ไม่ได้ทำอะไรเลยจนกว่า.Valueจะถูกเรียกจึงมีการสร้างวัตถุเพียงอินสแตนซ์เดียว

ตอนนี้สำหรับบางรหัส! ด้านล่างนี้เป็นวิธีการขยาย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());

ในการดำเนินการทั้งหมดแบบอะซิงโครนัสฉันขอแนะนำให้ใช้การใช้งานที่ยอดเยี่ยมของ Stephen Toubที่AsyncLazy<T>พบในบทความของเขาเกี่ยวกับ MSDN ซึ่งรวมการเริ่มต้นขี้เกียจในตัว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())
    { }
}   

ตอนนี้เป็นเวอร์ชัน async ของ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

ไปที่ด้านล่างสุดของหน้า (หรือค้นหาข้อความ "Thread Safety")

แล้วคุณจะได้เห็น:

^ ความปลอดภัยของเธรด

ประเภทนี้ปลอดภัยต่อด้าย

เพิ่งอัปโหลดไลบรารีตัวอย่างเพื่อแก้ไขปัญหาสำหรับ. Net 2.0

ดูที่ repo นี้:

RedisLazyCache

ฉันใช้แคช Redis แต่มันก็เฟลโอเวอร์หรือแค่ Memorycache หาก Connectionstring หายไป

มันขึ้นอยู่กับไลบรารี LazyCache ที่รับประกันการเรียกกลับเพียงครั้งเดียวสำหรับการเขียนในกรณีที่มีเธรดหลายชุดพยายามโหลดและบันทึกข้อมูลเป็นพิเศษหากการเรียกกลับมีราคาแพงมากในการดำเนินการ

แคชนั้นปลอดภัยสำหรับเธรด แต่ก็เหมือนกับที่คนอื่น ๆ ระบุไว้อาจเป็นไปได้ว่า GetOrAdd จะเรียก func หลายประเภทหากเรียกจากหลายประเภท

นี่คือการแก้ไขขั้นต่ำของฉันเกี่ยวกับเรื่องนั้น

private readonly SemaphoreSlim _cacheLock = new SemaphoreSlim(1);

และ

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

ดังที่ @AmitE กล่าวไว้ที่คำตอบของ @pimbrouwers ตัวอย่างของเขาไม่ทำงานตามที่แสดงไว้ที่นี่:

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