CODEWITHSUNDEEP
c#multithreading
Gopu_Tunas
Gopu_Tunas

Reputation: 194

Share local collection between Threads in C#

I have two methods as below

private void MethodB_GetId()
        {
            //Calling Method A constinuosly in different thread
            //Let's say its calling for Id = 1 to 100
        }

        private void MethodA_GetAll()
        {
            List<string> lst;
            lock(_locker)
            {
                lst = SomeService.Get(); //This get return all 100 ids in one shot.
                //Some other processing and then return result.
            }
        }

Now client is calling MethodB_GetById continuously for fetching data for id: 1 to 100 randomly. (It require some of data from these 100 Ids, not all data)

MethodA_GetAll get all data from network may be cache or database in one shot. and return whole collection to method B, then method B extract record in which it is interested.

Now if MethodA_GetAll() makes GetALL() times multiple times and fetching same records will be useless. so i can put a lock around it one thread is fetching record then other will be blocked.

Let's When MethodA_GetAll called by Id = 1 acquire lock and all others are waiting for lock to be released.

What i want is one data is available by any one thread just don't make call again.

Solution option: 1. Make List global to that class and thread safe. (I don't have that option)

I require some how thread 1 tell all other threads that i have record don't go fetching record again.

something like 

lock(_locker && Lst!=null) //Not here lst is local to every thread
{
   //If this satisfy then only fetch records 
}

Please excuse me for poorly framing question. I have posted this in little hurry.

Upvotes: 0

Views: 64

Answers (2)

Matthew Watson
Matthew Watson

Reputation: 109567

It sounds like you want to create a threadsafe cache. One way to do this is to use Lazy<t>.

Here's an example for a cache of type List<string>:

public sealed class DataProvider
{
    public DataProvider()
    {
        _cache = new Lazy<List<string>>(createCache);
    }

    public void DoSomethingThatNeedsCachedList()
    {
        var list = _cache.Value;

        // Do something with list.

        Console.WriteLine(list[10]);
    }

    readonly Lazy<List<string>> _cache;

    List<string> createCache()
    {
        // Dummy implementation.
        return Enumerable.Range(1, 100).Select(x => x.ToString()).ToList();
    }
}

When you need to access the cached value, you just access _cache.Value. If it hasn't yet been created, then the method you passed to the Lazy<T>'s constructor will be called to initialise it. In the example above, this is the createCache() method.

This is done in a threadsafe manner, so that if two threads try to access the cached value simultaneously when it hasn't been created yet, one of the threads will actually end up calling createCache() and the other thread will be blocked until the cached value has been initialised.

Upvotes: 1

Mark-Danney
Mark-Danney

Reputation: 138

You can try double-check-locking lst:

private List<string> lst;

private void MethodA_GetAll()
{
    if (lst == null)
    {
        lock (_locker)
        {
            if (lst == null)
            {
                // do your thing
            }
        }
    }
}

Upvotes: 0

Related Questions