D>не факт, что с Lazy сработает всегда и объект будет создан только один...

class Program
{
    static void DoTest()
    {
        var random = new Random();
        var start = new ManualResetEvent(false);
        var dict = new ConcurrentDictionary<string, int>();
        var results = new int[100];
        var threads = Enumerable.Range(0, 100).Select(i => new Thread(() =>
        {
            start.WaitOne(Timeout.Infinite, false);
            lock (results) results[i] = dict.GetOrAdd("key", x => i);
        }));
        threads.ToList().ForEach(x => x.Start());
        Thread.Sleep(100);
        start.Set();
        Thread.Sleep(100);
        var uniqueValues = results.Distinct().Select(x => x.ToString());
        Console.WriteLine("Unique values ({0}): {1}", uniqueValues.Count(), string.Join("/", uniqueValues));
    }

    static void Main(string[] args)
    {
        while (!Console.KeyAvailable)
        {
            DoTest();
        }

        Console.ReadKey();
    }
}

Sample output

Unique values (1): 96
Unique values (2): 0/95
Unique values (1): 95
Unique values (1): 96
Unique values (1): 97
Unique values (2): 0/97
Unique values (1): 96
Unique values (1): 96
Unique values (1): 97
Unique values (2): 0/98

Each time you see two values, it means that 2 threads received a different value for "key".

LW>Гениально! А как?

IDisposable localValue = null;
var globalValue = dict.GetOrAdd(key, _ =>
{
    localValue = valueFactory(_);
    return localValue;
});
if (globalValue != localValue)
{
    localValue?.Dispose();
}

S>class Program
S>{
S>    static void DoTest()
S>    {
S>        var random = new Random();
S>        var start = new ManualResetEvent(false);
S>        var dict = new ConcurrentDictionary<string, int>();
S>        var results = new int[100];
S>        var threads = Enumerable.Range(0, 100).Select(i => new Thread(() =>
S>        {
S>            start.WaitOne(Timeout.Infinite, false);
S>            lock (results) results[i] = dict.GetOrAdd("key", x => i);
S>        }));
S>        threads.ToList().ForEach(x => x.Start());
S>        Thread.Sleep(100);
S>        start.Set();
S>        Thread.Sleep(100);
S>        var uniqueValues = results.Distinct().Select(x => x.ToString());
S>        Console.WriteLine("Unique values ({0}): {1}", uniqueValues.Count(), string.Join("/", uniqueValues));
S>    }

S>    static void Main(string[] args)
S>    {
S>        while (!Console.KeyAvailable)
S>        {
S>            DoTest();
S>        }

S>        Console.ReadKey();
S>    }
S>}
S>

lock (results) results[i] = dict.GetOrAdd("key", x => i);

    public sealed class ConcurrentLockProvider<TKey>
    {
        private readonly Dictionary<TKey, Lock> _locks;

        public ConcurrentLockProvider()
            : this(EqualityComparer<TKey>.Default)
        {
        }

        public ConcurrentLockProvider(IEqualityComparer<TKey> comparer)
        {
            _locks = new Dictionary<TKey, Lock>(comparer);
        }

        public IDisposable Acquire(TKey key)
        {
            lock(_locks)
            {
                Lock item;
                if(!_locks.TryGetValue(key, out item))
                {
                    item = new Lock(key, _locks);
                    _locks[key] = item;
                }
                Interlocked.Increment(ref item.Counter);
                return item;
            }
        }

        private sealed class Lock : IDisposable
        {
            private readonly TKey _key;
            private readonly Dictionary<TKey, Lock> _dic;
            
            public long Counter;

            public Lock(TKey key, Dictionary<TKey, Lock> locks)
            {
                _key = key;
                _dic = locks;
            }

            #region Implementation of IDisposable

            public void Dispose()
            {
                lock(_dic)
                {
                    if(Interlocked.Decrement(ref Counter) < 1)
                        _dic.Remove(_key);
                }
            }

            #endregion
        }
    }

S>Unique values (1): 96
S>Unique values (2): 0/95
S>Unique values (1): 95
S>Unique values (1): 96
S>Unique values (1): 97
S>Unique values (2): 0/97
S>Unique values (1): 96
S>Unique values (1): 96
S>Unique values (1): 97
S>Unique values (2): 0/98
S>

Task.WaitAll(threads.ToArray())

var uniqueValues = results.Distinct().Select(x => x.ToString());

public class Base
{

    object SyncRoot {get;}
 
    public Base()
    {  
        SyncRoot = new object();
    }
}


public class A : Base
{
   ....
   public A( .... )
        :base()
   {
   }

}


var concurentDict = new ConcurentDictionary();
concurentDict['A'] = new A(....);

lock(concurentDict['A'].SyncRoot)
{

}

public interface ISyncRootProvider
{

    object SyncRoot {get;}
}


public class A : ..., ISyncRootProvider
{

   public object SyncRoot {get;}
   ....
   public A( .... )
        
   {
     ...
     SyncRoot = new object();
   }

}


var concurentDict = new ConcurentDictionary();
concurentDict['A'] = new A(....);

lock(concurentDict['A'].SyncRoot)
{

}