Не могу разобраться с работой потоков - C#

Формулировка задачи:

Сейчас изучаю работу потокв в C# Для меня основная польза от потоков - что можно работать быстрее,допустим чекер работает в 5 потоков в 5 раз быстрее и т.д Но я не мону разобраться с кое с чем.Допустим напишем простую программу,которая выводит в цикле числа до 500

 class Program
    {
        static object threadLockers = new object();
        static void Main()
        {
            Thread t1 = new Thread(Func); //1 шаг - обьявляем поток
            t1.Start(); //2 шаг - запускам поток
            Thread t2 = new Thread(Func);
            t2.Start();
 
        }
 
        static void Func()
        {
            for (int i = 1; i < 501; i++)
            {
                lock(threadLockers)
                {
                    Console.WriteLine(i);
                    Thread.Sleep(100);
                }
                
            }
            Console.ReadLine();
        }
    }

Тогда программа будем выводить

1
1
2
2
3
3
и т.д

Я вроде как заблокировал через lock доступ,но один поток как бы не видит другой и работа не распределяеться тоесть надо чтобы первый поток выводил 1,а второй уже 2 и т.д я думаю мысль понятна,но не могу понять как это сделать

Решение задачи: «Не могу разобраться с работой потоков»

textual
                            Листинг программы 
                        

                            using System;
using System.Collections.Generic;
using System.Threading;
 
namespace ConsoleApplication143
{
    internal class Program
    {
        private static void Main()
        {
            const int n = 5;
            ThreadStart start = () =>
                                {
                                    for (int i = 0; i < n; i++)
                                        Console.WriteLine("{0} {1}", i, Thread.CurrentThread.ManagedThreadId);
 
                                };
            var rrs = new RobinRoundSheduler(2, start) {TimeForTask = new TimeSpan(1)};
            rrs.Start();
            Console.ReadKey();
        }
    }
 
 
    internal class RobinRoundSheduler
    {
        private readonly LinkedList<Thread> _threads;
        public TimeSpan TimeForTask { get; set; }
 
        public RobinRoundSheduler(int taskCount, ThreadStart start)
        {
            TimeForTask = TimeSpan.FromSeconds(1);
            _threads = new LinkedList<Thread>();
            for (int i = 0; i < taskCount; i++)
            {
                _threads.AddLast(new Thread(start));
            }
        }
 
        public void Start()
        {
            while (_threads.Count > 0)
            {
                var list = new List<Thread>();
                foreach (var thread in _threads)
                {
                    lock (thread)
                    {
                        if (thread.ThreadState == ThreadState.Unstarted)
                            thread.Start();
                        else
                            thread.Resume();
                    }
                    thread.Join(TimeForTask);
                    lock (thread)
                    {
                        if (thread.ThreadState == ThreadState.Stopped || thread.ThreadState == ThreadState.Aborted)
                            list.Add(thread);
                        else
                        {
                            thread.Suspend();
                        }
                    }
                }
                list.ForEach(thread => _threads.Remove(thread));
            }
        }
    }
}
                        