sterowanie wątkami

Witam
Pomimo przeczytania wielu materiałów dotyczących wątków nadal nie wiem jak nimi sterować.
Nie wiem jak uzyskać coś takiego (nie wiem czy jest to w ogóle możliwe) aby po uruchomieniu _watek1 wywoływał on metodę MetodaPlik i dodatkowo blokował dostęp do niej do czasu zakończenia jej wykonywania. Czyli chciał bym otrzymać coś takiego aby _watek2 uzyskał dostęp do tej metody tylko wtedy jeśli inny wątek (_watek1) zwolni do niej dostęp.
To jest jeden pomysł choć nawet nie wiem czy w ogóle możliwy (proszę sie nie śmiać jeśli to całkowity bezsens)

Może jeśli opisze efekt końcowy jaki bym chciał uzyskać to zaproponujecie jakieś inne rozwiązanie :)
Chciał bym aby zapisywanie i odczytywanie z pliku nie zachodziło jednocześnie w kilku wątkach.
Jeśli macie jakiś pomysł/rozwiązanie to bardzo proszę o pomoc (najlepiej z jakimś małym przykładem, dużo łatwiej wtedy zrozumieć temat)

c#
private void button1_Click(object sender, EventArgs e)
{
Thread _watek1 = new Thread(new ThreadStart(wat1));
Thread _watek2 = new Thread(new ThreadStart(wat2));

        _watek1.Start();
        _watek2.Start();
    }

    public void wat1()
    {
       MetodaPlik();
    }
    
    public void wat2()
   {
      MetodaPlik();
   }

    public void MetodaPlik()
    {
      // odczytywanie i zapisywanie z/do pliku
    }

W Delphi było coś takiego jak sekcje krytyczne (TRTLCriticalSection)

EnterCriticalSection(); // początek sekcji krytycznej
LeaveCriticalSection(); // koniec sekcji krytycznej

Poszukaj na google czy jest implementacja tego w .NET (a na pewno jest).

Link:
http://www.csharphelp.com/archives/archive128.html

Thread Synchronization:

A multithreaded application usually has resources that can be accessed from multiple threads; for example, a global variable that is incremented or decremented by multiple threads. It is sometimes desirable to prevent multiple threads from concurrently altering the state of a resource. The .NET Framework includes several classes and data types that we can use to synchronize actions performed by two threads.

The simplest case is if we have a shared variable that we need to update from different threads. To do this, we can use the System.Threading.Interlocked class. For example, to increment or decrement the shared variable called num, we'd write Interlocked.Increment(num) or Interlocked.Decrement(num). we can also use Interlocked to set the variables to a specific value or to check the equality of two variables.

If there's a section of code in an object's method that should not be accessed concurrently by multiple threads, we can use the Monitor class to acquire a lock on that object by calling Monitor.Enter(object). Any other thread wanting to execute the same code would need to acquire the same lock and will be paused until the first thread releases the lock by calling Monitor. Exit(object).

Nie wiem czy to chodzi o to ale może się przyda.

private void button1_Click(object sender, EventArgs e)
        {
            Thread _watek1 = new Thread(new ThreadStart(wat1));
            Thread _watek2 = new Thread(new ThreadStart(wat2));
           
            _watek1.Start();
            _watek2.Start();
        }

        public void wat1()
        {
           MetodaPlik();
        }
        
        public void wat2()
       {
          MetodaPlik();
       }

        object zamknij = new object();

        public void MetodaPlik()
        {
            lock(zamknij)
            {
                 // odczytywanie i zapisywanie z/do pliku
            }
        }

Wielkie dzięki majster590 właśnie o to chdziło :)