Как заставить один поток ждать, пока работает другой

public static bool[] forks = new bool[5];// false - свободна
 
public void takeFirstSpoon(int i)
        {
            lock (locker)
            {
               if (!forks[i]){ //если свободна
                    forks[i] = true; //то занять
                }
                else
                {
                    takeFirstSpoon(i); //вот тут, по сути, поток должен сбросить эту блокировку
//и начать заново пытаться занять forks[i]. Но получается, что лок-в-локе-в-локе и т.д.
//Не могу понять, как заставить поток ждать, пока другой освободит forks[i].
//(i -меняется, так что в плане, реально ли другой поток освобождает ячейку, то да.)
                };
            }
 
            takeSecondSpoon(i);
        }

class BasicWaitHandle
{
static EventWaitHandle _waitHandle = new AutoResetEvent (false);
static void Main()
{
new Thread (Waiter).Start();
Thread.Sleep (1000); // Pause for a second...
_waitHandle.Set(); // Wake up the Waiter.
}
static void Waiter()
{
Console.WriteLine ("Waiting...");
_waitHandle.WaitOne(); // Wait for notification
Console.WriteLine ("Notified");
}
}

internal class Program
    {
        private static readonly EventWaitHandle _waitHandle = new AutoResetEvent(false);
        private static bool[] forks;
        private static bool start = true;
 
        private static void TakeFirstSpoon(object input)
        {
            int i = (int)input;
            if (start)
            {
                start = false;
            }
            else
            {
                _waitHandle.WaitOne();
            }
            
            TakeSecondSpoon(i);
        }
 
        private static void TakeSecondSpoon(int i)
        {
            Thread.Sleep(1000);
            forks[i] = true;
            Console.WriteLine("Thread: {0} Index: {1} ", Thread.CurrentThread.GetHashCode(), i);
            _waitHandle.Set();
        }
 
        private static void Main(string[] args)
        {
            forks = new bool[5]; // false - свободна
            forks.Initialize();
            for (int i = 0; i < forks.Length; i++)
            {
                if (!forks[i])
                {
                    var newThread = new Thread(TakeFirstSpoon);
                    newThread.Start(i);
                    Console.WriteLine("Thread: {0} started", newThread.GetHashCode());
                }
            }
            Console.WriteLine();
            Console.ReadLine();
        }
    }

internal class Program
    {
        private static bool[] forks;
 
        private delegate int MethodDelegate(int i);
 
        private static readonly Random r = new Random();
 
        [System.Runtime.InteropServices.DllImport("winmm.DLL", EntryPoint = "PlaySound", SetLastError = true)]
        private static extern bool PlaySound(string szSound, IntPtr hMod, PlaySoundFlags flags);
 
        [System.Flags]
        public enum PlaySoundFlags{SND_ASYNC = 0x0001}
 
        private static void Main()
        {
            MethodDelegate methodDelegate = LongRunMethod;
            forks = new bool[5]; // false - свободна
            forks.Initialize();
            for (int i = 0; i < forks.Length; i++)
            {
                IAsyncResult iAsyncResult = methodDelegate.BeginInvoke(i,new AsyncCallback(AsyncCallbackMethod),methodDelegate);
                // Progress
                int count = 0;
                while (iAsyncResult.IsCompleted == false)
                {
                    if (count > 0)
                    {
                        Console.WriteLine("Main thread {0} seconds waiting for callback...", count);
                    }
                    Thread.Sleep(1000);
                    count++;
                }
            }
 
            Console.WriteLine(":)");
            Console.ReadLine();
        }
 
        private static void AsyncCallbackMethod(IAsyncResult ar)
        {
            MethodDelegate methodDelegate = (MethodDelegate)ar.AsyncState;
            int i = methodDelegate.EndInvoke(ar);
            Console.WriteLine("IAsyncResult for {0} completed. Thread: {1} ", i, Thread.CurrentThread.GetHashCode());
        }
 
        private static int LongRunMethod(int i)
        {
            Thread.Sleep(r.Next(i * 3000));
            forks[i] = true;
            Console.WriteLine("LongRunMethod finished. Index: {0}.", i);
            PlaySound(@"C:\Windows\Media\tada.wav", new IntPtr(), PlaySoundFlags.SND_ASYNC);
            return i;
        }
    }