СГ>  System.Monitor.Enter(this);
СГ>

class MySyncClass
{
    object sync_obj = new object();
    public void foo()
    {
        lock (sync_obj)
        {
            // modify me
        }
    }
}

System.Threading.Monitor.Enter(obj)
try
{
  ...эксклюзивный блок кода
}
finally
{
  System.Threading.Monitor.Exit(obj);
}

        public object Dequeue ()
        {
            // перед этой командой потоки ставятся в очередь: внутрь вход по одному!
            lock (this)
            {
                // Проникнув внутрь эксклюзивного блока, поток проверяет очередь на непустоту,
                // если она пуста - засыпает. Как только он засыпает по Wait, то объект this становится
                // вновь доступен для других потоков. Раз так, то какой-то другой поток может вызвать
                // метод Enqueue и сделать очередь непустой. В конце метода Enqueue зовётся PulseAll.
                // Сработавший PulseAll будит уснувшие на этом объекте потоки. Разбуженные потоки вновь
                // впускаются внутрь эксклюзивного блока (по одному), 
                // из которого они были временно выведены на время своего сна
                while (this.head == null) System.Threading.Monitor.Wait(this);

                object r = this.head.element;
                this.head = this.head.next;
                if (this.head == null) this.tail = null;
                System.Threading.Monitor.PulseAll(this);
                return r;
            }
        }

MODULE Buffers;

CONST
  BufLen = 256;
  
TYPE
  (* Buffer- First-in first-out buffer *)

  Buffer* = OBJECT
    VAR
      data: ARRAY BufLen OF INTEGER;
      in, out: LONGINT;
      
    (* Put - insert element into the buffer *)
    
    PROCEDURE Put* (i: INTEGER);
    BEGIN {EXCLUSIVE}
      AWAIT ((in + 1) MOD BufLen # out);  (*AWAIT ~full *)
      data[in] := i;
      in := (in + 1) MOD BufLen
    END Put;
    
    (* Get - get element from the buffer *)
    
    PROCEDURE Get* (VAR i: INTEGER);
    BEGIN {EXCLUSIVE}
      AWAIT (in # out);  (*AWAIT ~empty *)
      i := data[out];
      out := (out + 1) MOD BufLen
    END Get;
    
    PROCEDURE & Init;
    BEGIN
      in := 0; out := 0;
    END Init;
  
  END Buffer;

END Buffers.

bool Dequeue (out object obj);

if (queue.Dequeue(out x))
{
  ...
}
else
{
  ... очередь оказалась пустой
}

System.Monitor.Enter(this);
  try
  {
  }
  finally
  {
    System.Monitor.PulseAll(this);
    System.Monitor.Exit(this);
  }

TYPE ClassA = CLASS
  ptrB: POINTER TO ClassB;
END;
TYPE ClassB = CLASS
  ptrA: POINTER TO ClassA;
END;


FUNCTION Construct(): POINTER TO ClassA;
BEGIN
  ptrA := NEW ClassA;
  ptrA.ptrB := NEW ClassB;
  ptrA.ptrB.ptrA := ptrA;
  Construct := ptrA;
END;


PROCEDURE ClassA.foo;
BEGIN {exclusive}
  .....
  this.ptrB.foo();
  .....
END;
PROCEDURE ClassB.foo;
BEGIN {exclusive}
  .....
END;


PROCEDURE ClassB.bar;
BEGIN {exclusive}
  .....
  this.ptrA.bar();
  .....
END;
PROCEDURE ClassA.bar;
BEGIN {exclusive}
  .....
END;

    public class A1
    {
        public Smth Smth
        {
            get { return new Smth("Smth from A1"); }
        }

        public void DoA1(A2 a2)
        {
            Smth s = a2.Smth;
            lock (this)
            {
                // некие операции с иполоьзованием this и s
            }
        }
    }

    public class A2
    {
        public Smth Smth
        {
            get { return new Smth("Smth from A2"); }
        }

        public void DoA2(A1 a1)
        {
            Smth s = a1.Smth;
            lock (this)
            {
                // некие операции с иполоьзованием this и s
            }
        }
        public void MethForA2()
        {
            lock (this)
            {
                // некие операции с иполоьзованием this
            }
        }
    }

    public class D
    {
        public void MethForA1A2(A1 a1, A2 a2)
        {
            // синхронизирует все операцию целиком, а не данные a1 и a2
            // если additionalProcessing нет, то просто переносим все либо в A1 либо в A2
            lock (this)
            {
                a1.DoA1(a2);
                additionalProcessing(a1,a2);
                a2.DoA2(a1);
            }
        }

        private void additionalProcessing(A1 a1, A2 a2)
        { }
    }

СГ>>object Dequeue();
СГ>>

СГ>>bool TryDequeue(out object obj);
СГ>>

object Dequeue();

PROCEDURE DoSmth;
BEGIN
  ...
  BEGIN {EXCLUSIVE} this.a := a1; this.b := b1 END; (* значения измененяются одной атомарной операцией *)
  ...
  BEGIN {EXCLUSIVE} this.a := a2; this.b := b2 END; (* значения измененяются одной атомарной операцией *)
  ...
END DoSmth;

System.Threading.Monitor.Enter(this);
try
{
  ...
  ...
  ...
  return x;
}
finally
{
  System.Threading.Monitor.PulseAll(this);
  System.Threading.Monitor.Exit(this);
}

lock (this)
{
  try
  {
    ...
    ...
    ...
    return x;
  } 
  finally
  {
    System.Threading.Monitor.PulseAll(this);
  }
}