C# Online Compiler | .NET Fiddle

#nullable enable
using System;
using System.Threading.Tasks;
using System.Threading;
using System.Collections.Generic;
using System.Diagnostics;

					
public class Program
{
	public static async Task Main()
	{
		int threadCount = 30;

		var svc = new Services.Service();
		
		var tasks = new Task[threadCount];
		
		var stopwatch = Stopwatch.StartNew();
		
        for (int i = 0; i < threadCount; i++)
        {
            tasks[i] = Task.Run(() =>
            {
                Console.WriteLine($"Preço do produto #5 R$ {svc.GetPrice(5)}");
            });
        }

		// Aguardando todas as tarefas finalizarem
        await Task.WhenAll(tasks);
		
		stopwatch.Stop();
		
		Console.WriteLine($"Todas as tarefas foram executadas em {stopwatch.ElapsedMilliseconds} ms.");
	}
	
	
}

namespace Services
{
	public class Service
	{
		private Infrastructure.SafeCacheService SafeCacheService = new();
		private Infrastructure.Data.ProductRepository Repository = new();
		
		public decimal? GetPrice(int productId, bool useCache = true) 
			=> useCache 
				? SafeCacheService.GetFromCacheOrExecute<decimal?>($"cache:product:{productId}:price",  TimeSpan.FromSeconds(2), 5, () => this.Repository.GetPriceByProduct(productId))
				: this.Repository.GetPriceByProduct(productId); 
	}
}





namespace Infrastructure 
{
	
	public class SafeCacheService
	{
		private Infrastructure.PseudoRedis Redis = new();
		
		public T? GetFromCacheOrExecute<T>(string key, TimeSpan lockTimeOut, int retry, Func<T?> longWayFunc)
		{			
		  T? returnValue = this.Redis.Get<T?>(key);
		  if(returnValue == null)
		  {			
			string lockKey = $"{key}:lock";
			using (var lockcontrol = this.Redis.Lock(key: lockKey, timeout: TimeSpan.FromSeconds(2), retry: 5))
			{
			  returnValue = this.Redis.Get<T?>(key);
			  if(returnValue == null)
			  {
				Console.WriteLine($"Usando mecanismo lento----------------");
				returnValue = longWayFunc();
				this.Redis.Set(key, returnValue);
			  }
			}
		  }
		  return returnValue;
		}
	}

	
	public class PseudoRedis
	{
		private Dictionary<string, object> cacheMemory = new();
		private Dictionary<string, object> lockKeys = new();

		public void Set<T>(string key, T? objectToStore){
			if(objectToStore == null) return;		
			
			cacheMemory[key.ToLowerInvariant()] = objectToStore;
		}
		
		public T Get<T>(string key)
		{
			key = key.ToLowerInvariant();
			return this.cacheMemory.ContainsKey(key) ? (T)cacheMemory[key] : default;			
		}			
		
		private static object syncLoc = new Object();
		public IDisposable Lock(string key,TimeSpan timeout, int retry)
		{
			key = key.ToLowerInvariant();			
			object lockObject;
			lock(syncLoc)
			{
				if(lockKeys.ContainsKey(key))
					lockObject = lockKeys[key];
				else
				{
					lockObject = new Object();
					lockKeys[key] = lockObject;
				}
			}
			return new LockScope(key, lockObject, timeout, retry);
		}
		
	}
	
	public class LockScope : IDisposable
	{
		private readonly object _lockObject;
		private readonly bool _lockAcquired;

		public string Key { get; }
		public TimeSpan Timeout { get; }
		public int Retry { get; }

		public LockScope(string key, object lockObject, TimeSpan timeout, int retry)
		{
			_lockObject = lockObject;
			Key = key;
			Timeout = timeout;
			Retry = retry;

			_lockAcquired = TryAcquireLock();
			if (!_lockAcquired)
			{
				throw new TimeoutException($"Unable to acquire lock for key '{Key}' within the timeout period.");
			}
		}

		private bool TryAcquireLock()
		{
			for (int i = 0; i < Retry; i++)
			{
				if (Monitor.TryEnter(_lockObject, Timeout))
				{
					return true;
				}
				
				// Caso o bloqueio não seja obtido, espera antes de tentar novamente
				//Thread.Sleep(Timeout);
				Thread.Sleep(10);
			}

			return false;
		}

		public void Dispose()
		{
			if (_lockAcquired)
			{
				Monitor.Exit(_lockObject);
			}
		}
	}	
	
}

namespace Infrastructure.Data 
{
	public class ProductRepository
	{	Random rnd = new Random();
	 
		public decimal? GetPriceByProduct(int productId)
		{
			decimal? price = rnd.Next(1000);
			int sleep = rnd.Next(500, 1500);
			
			Console.WriteLine($"Entregando preço R$ {price}, com lentidão de {sleep}ms");
			System.Threading.Thread.Sleep(sleep);
			return price;			
		}		
	}
}

 
#nullable enable
using System;
using System.Threading.Tasks;
using System.Threading;
using System.Collections.Generic;
using System.Diagnostics;
​
                    
public class Program
{
    public static async Task Main()
    {
        int threadCount = 30;
​
        var svc = new Services.Service();
        
        var tasks = new Task[threadCount];
        
        var stopwatch = Stopwatch.StartNew();
        
        for (int i = 0; i < threadCount; i++)
        {
            tasks[i] = Task.Run(() =>
            {