Testing http://stackoverflow.com/questions/12163125/is-locking-necessary-in-this-concurrentdictionary-caching-scenario

gistfile1.cs

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

namespace GeneralTests
{
    internal class Program
    {

        public class SomeClass
        {
            private static readonly ConcurrentDictionary<int, PrivateClass> SomeClasses =
                new ConcurrentDictionary<int, PrivateClass>();

            private readonly PrivateClass _privateClass;

            public SomeClass(int cachedInstanceId)
            {

                _privateClass = SomeClasses.GetOrAdd(cachedInstanceId, (key) => new Lazy<PrivateClass>(() => new PrivateClass(key)).Value);

            }

            public int SomeCalculationResult()
            {
                return _privateClass.CalculateSomething();
            }

            private class PrivateClass
            {
                public PrivateClass(int id)
                {
                    Thread.Sleep(1000);
                    Console.WriteLine("CONSTUCTOR");
                }

                internal int CalculateSomething()
                {
                    Console.WriteLine("CALCULATOR");
                    return 10;
                }
            }
        }


        private static void Main(string[] args)
        {
            var tasks = new Task[Environment.ProcessorCount];
            for (int i = 0; i < Environment.ProcessorCount; i++)
            {
                tasks[i] = Task.Factory.StartNew(() =>
                    {
                        new SomeClass(1).SomeCalculationResult();
                    });
            }
            Task.WaitAll(tasks);
            Console.WriteLine("Sleeping a bit");
            Thread.Sleep(2000);
            new SomeClass(1).SomeCalculationResult();
            // Output:
            // CONSTUCTOR
            // CONSTUCTOR
            // CONSTUCTOR
            // CALCULATOR
            // CALCULATOR
            // CONSTUCTOR
            // CALCULATOR
            // CALCULATOR
            // Sleeping a bit
            // CALCULATOR
        }
    }
}