মেমোরিচেড থ্রেড সুরক্ষা, লক করা কি প্রয়োজনীয়?

Question 1

আরম্ভকারীদের জন্য আমাকে এটি কেবল এখানে ফেলে দিন যে আমি জানি যে নীচের কোডটি থ্রেড নিরাপদ নয় (সংশোধন: হতে পারে)। আমি যেটির সাথে লড়াই করছি তা হ'ল এমন একটি বাস্তবায়ন খুঁজে পাওয়া যা আমি আসলে পরীক্ষার অধীনে ব্যর্থ হতে পারি। আমি এখনই একটি বড় ডাব্লুসিএফ প্রকল্পটি রিফ্যাক্টর করছি যার জন্য কিছু (বেশিরভাগ) স্থিতিশীল ডেটা থাকা দরকার এবং এটি একটি এসকিউএল ডাটাবেস থেকে পপুলেটেড। দিনে অন্তত একবার এটির মেয়াদ শেষ হয়ে যাওয়া এবং "রিফ্রেশ" করা দরকার যার কারণে আমি মেমোরিচ্যাচ ব্যবহার করছি।

আমি জানি যে নীচের কোডটি থ্রেড নিরাপদ হওয়া উচিত নয় তবে ভারী বোঝার নিচে ব্যর্থ হওয়া এবং বিষয়গুলিকে জটিল করতে গুগল অনুসন্ধান কার্যকরভাবে উভয় উপায়ে (প্রয়োজনীয় তালিকাগুলির সাথে এবং লকগুলি ছাড়াও প্রয়োজনীয় প্রয়োজন কিনা তা দেখায়) get

একাধিক থ্রেড পরিবেশে মেমোরি ক্যাশের জ্ঞানযুক্ত কেউ কি আমাকে যথাযথভাবে লক করতে হবে কিনা তা আমাকে নিশ্চিতভাবে জানাতে পারে যাতে রিমুভাল / রিপোপুলেশন চলাকালীন একটি কল (যা খুব কমই বলা হবে তবে এটি প্রয়োজনীয়তা হবে) সরাতে পারে না।

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

Question 2

ডিফল্ট এমএস-সরবরাহ MemoryCacheসম্পূর্ণ থ্রেড নিরাপদ। যে কোনও কাস্টম বাস্তবায়ন যা থেকে প্রাপ্ত MemoryCacheথ্রেড নিরাপদ নাও হতে পারে। আপনি যদি MemoryCacheবাক্সের বাইরে প্লেইন ব্যবহার করেন তবে এটি থ্রেড নিরাপদ। আমি কীভাবে এটি ব্যবহার করি তা দেখতে আমার ওপেন সোর্স বিতরণ করা ক্যাচিং সমাধানের উত্স কোডটি ব্রাউজ করুন:

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

Question 3

অন্য উত্তরগুলি যেমন উল্লেখ করেছে মেমোরিসিচে প্রকৃতপক্ষে থ্রেড নিরাপদ, এতে একটি সাধারণ মাল্টি থ্রেডিং সমস্যা রয়েছে - যদি 2 থ্রেড একই সাথে ক্যাশে Getথেকে (বা পরীক্ষা করে Contains) দেখার চেষ্টা করে তবে উভয়ই ক্যাশে মিস করবে এবং উভয়ই উত্পাদন শেষ করবে ফলাফল এবং উভয়ই এরপরে ক্যাশে ফলাফল যুক্ত করবে।

প্রায়শই এটি অনাকাঙ্ক্ষিত - দ্বিতীয় থ্রেডটি প্রথমে সম্পূর্ণ হওয়ার জন্য অপেক্ষা করা উচিত এবং দুবার ফলাফল উত্পন্ন করার পরিবর্তে এর ফলাফলটি ব্যবহার করা উচিত।

আমি LazyCache লেখার একটি কারণ ছিল - মেমোরিচেচে একটি বন্ধুত্বপূর্ণ মোড়ক যা এই ধরণের সমস্যার সমাধান করে। এটি নুগেটেও উপলব্ধ ।

Question 4

অন্যরা যেমন বলেছে, মেমোরিচেস সত্যই থ্রেড নিরাপদ। এটির মধ্যে সঞ্চিত ডেটার থ্রেড সুরক্ষাটি সম্পূর্ণরূপে আপনার এটির ব্যবহারের উপর নির্ভর করে।

সম্মতি এবং প্রকার সম্পর্কিত রিড কোপসিকে তার দুর্দান্ত পোস্ট থেকে উদ্ধৃত করা ConcurrentDictionary<TKey, TValue>। যা অবশ্যই এখানে প্রযোজ্য।

যদি দুটি থ্রেড একই সাথে [getOrAdd] কল করে তবে টিভিালুর দুটি উদাহরণ সহজেই নির্মিত যেতে পারে।

আপনি কল্পনা করতে পারেন যে এটি TValueনির্মাণে ব্যয়বহুল হলে এটি বিশেষত খারাপ ।

আপনার চারপাশে কাজ করার জন্য, আপনি Lazy<T>খুব সহজেই লাভ করতে পারেন, যা কাকতালীয়ভাবে নির্মাণ করা খুব সস্তা cheap এটি করা নিশ্চিত করে যদি আমরা বহুবিবাহিত পরিস্থিতিতে পড়ে যাই, তবে আমরা কেবল একাধিক উদাহরণ তৈরি করছি 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());

এই সমস্ত অ্যাসক্রোনাকলভাবে সম্পাদন করার জন্য, আমি স্টিফেন টুবের এমএসডিএন সম্পর্কিত AsyncLazy<T>তার নিবন্ধে পাওয়া দুর্দান্ত বাস্তবায়নটি ব্যবহার করার পরামর্শ দিচ্ছি । যা বিল্টিন অলস ইনিশিয়ালাইজারকে 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());

Question 5

এই লিঙ্কটি দেখুন: http://msdn.microsoft.com/en-us/library/system.runtime.caching.memorycache(v=vs.110).aspx

পৃষ্ঠার একেবারে নীচে যান (বা "থ্রেড সুরক্ষা" পাঠ্যের জন্য অনুসন্ধান করুন)।

তুমি দেখবে:

Read থ্রেড সুরক্ষা

এই ধরণের থ্রেড নিরাপদ।

Question 6

নেট নেট ২.০ এর জন্য ইস্যুটি সমাধান করার জন্য স্যাম্পল লাইব্রেরি সদ্য আপলোড করা হয়েছে।

এই রেপো একবার দেখুন:

RedisLazyCache

আমি রেডিস ক্যাশে ব্যবহার করছি তবে কানেকশনস্ট্রিং অনুপস্থিত থাকলে এটি ফেইলওভার বা কেবল মেমোরিচিচি ব্যবহার করে।

এটি LazyCache লাইব্রেরি ভিত্তিক যা কলব্যাক কার্যকর করার জন্য খুব ব্যয়বহুল হলে বিশেষভাবে ডেটা লোড করার এবং সংরক্ষণ করার চেষ্টা করার ক্ষেত্রে মাল্টি থ্রেডিংয়ের ইভেন্টে লেখার জন্য কলব্যাকের একক প্রয়োগের গ্যারান্টি দেয়।

Question 7

@ অ্যামিটি @ জিম্বাবুয়েদের উত্তরগুলিতে যেমন উল্লেখ করেছেন, তার উদাহরণ এখানে প্রদর্শিত হিসাবে কাজ করছে না:

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

Question 8

ক্যাশে থ্রেডসেফ, তবে অন্যদের মতোই এটিও সম্ভব হয়েছে যে একাধিক প্রকারের কল পেলে getOrAdd ফানকে একাধিক ধরণের কল করবে।

এটি আমার ন্যূনতম স্থির

private readonly SemaphoreSlim _cacheLock = new SemaphoreSlim(1);

এবং

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