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)
{
.....
//Изменения с внешней стороны
....
}
}
...
}