int usingResource=false;

static bool UseResource()
   {
       atom
       {
          if( usingResource ) return;
          usingResource=true;
       }

        ....
        ....
        .....
        usingResource=false;    
     }

        //0 for false, 1 for true.
        private static int usingResource = 0;

        //A simple method that denies reentrancy.
        static bool UseResource()
        {
            //0 indicates that the method is not in use.
            if(0 == Interlocked.Exchange(ref usingResource, 1))
            {
                Console.WriteLine("{0} acquired the lock", Thread.CurrentThread.Name);
            
                //Code to access a resource that is not thread safe would go here.
            
                //Simulate some work
                Thread.Sleep(500);

                Console.WriteLine("{0} exiting lock", Thread.CurrentThread.Name);
            
                //Release the lock
                Interlocked.Exchange(ref usingResource, 0);
                return true;
            }
            else
            {
                Console.WriteLine("   {0} was denied the lock", Thread.CurrentThread.Name);
                return false;
            }
        }

int usingResource=false;

static bool UseResource()
   {
       atom
       {
          if( usingResource ) return;
          usingResource=true;
        }

        for(; ;);
        ....
        .....
        usingResource=false;    
     }

BEGIN {EXCLUSIVE} (* changes to both x and y are atomic *)
  x := x0;  y := y0;
END;

MODULE BoundedBuffers;

TYPE
  Item* = OBJECT; (* generic object *)
  

  Buffer* = OBJECT
    VAR h, n: INTEGER;  B: ARRAY * OF Item;

    PROCEDURE Get*(): Item;
    VAR x: Item;
    BEGIN {EXCLUSIVE}
      AWAIT(n # 0); (* buffer not empty *)
      x := B[h]; h := (h+1) MOD LEN(B); DEC(n);
      RETURN x
    END Get;

    PROCEDURE Put*(x: Item);
    BEGIN {EXCLUSIVE}
      AWAIT(n # LEN(B)); (* buffer not full *)
      B[(h+n) MOD LEN(B)] := x; INC(n)
    END Put;

    PROCEDURE &Init(max: INTEGER);
    BEGIN (* initializer *)
      NEW(B, max); h := 0; n := 0
    END Init;

  END Buffer;


END BoundedBuffers.

boolean usingResource = false;
Object lock = new Object();

static boolean useResource() {
  synchronized (lock) {
    if (usingResource)
      return false;
    usingResource = true;
  }
  ....
  ....

  synchronized (lock) {
    usingResource = false;
  }
}

int x = 1, y = 2;

void sum_thread() { printf("%d, %d", x, y); }

void toggle_thread() { atom { swap(x,y); } }

int x = 1, y = 2;

void sum_thread() { atom {printf("%d, %d", x, y)}; }

void toggle_thread() { atom { swap(x,y); } }

int x = 1, y = 2;

void sum_thread() 
{


int X, Y;


  atom
    {
      X=x;
      Y=y
    }
 
   printf("%d, %d", X, Y); 
}

void toggle_thread() { atom { swap(x,y); } }

public static void main(String args[])
    {
    
     for(;;);
    
    }

class A
{
.....
property Result prop
{
//изменения и работа с внутренней стороны
get{lock(this){....}}
set{lock(this){....}}
}
....
}

class B
{
...
A _a;
void aaa()
{
lock(_a)
{
.....
//Изменения с внешней стороны
....
}
}
...
}

while(!take(semaphore, 0)) {}

// ACQUIRE 
//
retries = 0; 
while( !TryEnterCriticalSection(&CritSec) ){ 
  if( retries++ < 100 ){ 
    if( retries % 10 ){         // DelayBetweenReferences 
      for( i=0; i<Delay; i++);  // Delay = 1<<(cpus-1) 
    } else { 
      SwitchToThread();         //10 ctxsw max    
    } 
    continue; 
  } 
  EnterCriticalSection(&CritSec);    
  break; 
} 

// RELEASE 
//
LeaveCriticalSection(&CritSec);

некий код
...
BEGIN {EXCLUSIVE}
  n := n + delta
END
...
некий код

некий код
...
INC(n, delta);
...
некий код

if (Interlocked.CompareExchange(ref locked, 1, 0) == 0)
 {
  .......
  .......
  .......

   
  locked=0
 }

void method()
{
  EXCLUSIVE exc; // Должен влиять на планировщик.
    // Поехали!
    
    AWAIT(condition); // condition - адрес функции или замыкание или делегат
}

if (Interlocked.CompareExchange(ref locked, 1, 0) == 0)

locked=0;

class A
{
    public B b;
    public void m1()
    {
        lock(this)
        {
            b.m1();
        }
    }
    public void m2()
    {
        lock(this)
        {
          // что-то унутреннее
        }
    }
}

class B
{
    public A a;

    public void m1()
    {
        lock(this)
        {
          // что-то унутреннее
        }
    }
    public void m2()
    {
        lock(this){
            a.m2();
        }
    }
}

// инициализация
A my_a = new A();
B my_b = new B();
my_a.b = my_b;
my_b.a = my_a;

// теперь из разных потоков одновременно вызываем:
my_a.m1();
// и
my_b.m2();

lock(my_a){
lock(my_b){
  my_a.m1();
}
}

// и другой поток:
lock(my_a){
lock(my_b){
  my_b.m2();
}
}

lock(my_a){
lock(my_b){
  my_a.m1();
}
}

// и другой поток:
lock(my_b){
lock(my_a){
  my_b.m2();
}
}

class B
{
    public void m2()
    {
       a.m2();
    }
}

class B
{
    public void m2()
    {
        lock(a) {            
        lock(this)
            {
       a.m2();
            }
            }
    }
}

// таблицы зависимостей
mutex waiting(thread); // кого ждёт данный поток
thread locked(mutex); // кто держит данного мутекса

bool check_deadlock(thread t, mutex m) // true если дедлок
{
  if(locked(m)==t) return false; // реентер - разрешён (для семафоров так делать нельзя, разумеется)

  while(true)
  {
    thread d = locked(m);
    if(!d) return false;
    if(d==t) return true;

    m = waiting(d);
    if(!m) return false;
  }
}