Lock должен блокировать при заполнении - чтение и заполнение, а при чтении ничего

SortedDictionary<string, string> SortedDic = new SortedDictionary<string, string>();
private ReaderWriterLockSlim cacheLock = new ReaderWriterLockSlim();
 
private void multithreadSortDic()
        {
            SortedDic.Clear();
            int threadWait = 0;
            bool threadWork = false;
            string t;
            for (int i = 0; i < 200000; i++) 
            {
                t = i.ToString();
                if (!SortedDic.ContainsKey(t))
                {
                    SortedDic.Add(t, t);
                }
            }
 
            Thread[] threads1 = new Thread[8]; // потоки для изменения значений по ключам
            for (int i = 0; i < threads1.Length; i++)
            {
                int threadId = i;
                Thread.Sleep(3);
                threads1[i] = new Thread(delegate ()
                {
                    while (!threadWork) { Thread.Sleep(10); } // ожидание команды для работы потоков
 
                    int iterCount = (400000 / threads1.Count()); // при любом числе потоков кол-во итераций в сумме будет равным 400к
                    int count = 0;
 
                    for (int k = 0; k < iterCount; k++)
                    {
                        string c = count.ToString();
                        if (count >= 99999) { count = 0; }
                        count++;
 
                        SortedDic[c] = "t" + c;
                    }
 
                    threadWait++;
 
                });
                threads1[i].Start();
            }
 
            Thread[] threads2 = new Thread[8]; // потоки для чтения значений по ключам
            for (int i = 0; i < threads2.Length; i++)
            {
 
                int threadId = i;
                Thread.Sleep(3);
                threads2[i] = new Thread(delegate ()
                {
                    while (!threadWork) { Thread.Sleep(10); } // ожидание команды для работы потоков
 
                    float iterCount = (600000 / threads2.Count()); // при любом числе потоков кол-во итераций в сумме будет равным 600к
                    int count = 0;
 
 
                    string result;
                    for (int k = 0; k < iterCount; k++)
                    {
                        if (count >= 99999)
                        {
                            count = 0;
                        }
                        count++;
 
                        if (SortedDic.TryGetValue(count.ToString(), out result))
                        {
 
                        }
                        else
                        {
                            Console.WriteLine("Not found: " + count.ToString());
                        }
 
                    }
 
                    threadWait++;
 
                });
                threads2[i].Start();
            }
 
 
            Thread.Sleep(1000); // ожидание для инициализации потоков
            Console.WriteLine("done");
 
            timerStart(); // запускаем таймер
            threadWork = true; // разрешаем потокам начать работу
 
 
            cacheLock.EnterWriteLock();
            for (int i = 0; i < 50000; i++)  // добавляем 50000 записей, чисто ради теста, в реальности будет 100-200 в секунду
            {
                t = i.ToString();
                SortedDic["y" + t] = t;
               
            }
            cacheLock.ExitWriteLock();
 
 
            while (threadWait < (threads1.Count() + threads2.Count())) { Thread.Sleep(10); } // ожидаем пока потоки выполнят свои циклы записи и чтения
 
            timerStop(1); // останавливаем таймер
            Console.WriteLine(SortedDic.Count);
 
            foreach (var thread in threads1) // убиваем потоки записи
            {
                thread.Abort(); 
            }
            foreach (var thread in threads2) // убиваем потоки чтения
            {
                thread.Abort();
            }
            multithreadSortDic(); // для длительного тестирования запускаем повторно
        }