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;
  }
}

InterlockedExchange
The InterlockedExchange function atomically exchanges a pair of values. The function prevents more than one thread from using the same variable simultaneously.

If you are exchanging pointer values, this function has been superseded by the InterlockedExchangePointer function.

LONG InterlockedExchange(
  LPLONG Target, // value to exchange
  LONG Value     // new value
);

Parameters
Target
[in/out] Pointer to the value to exchange. The function sets this variable to Value, and returns its prior value.
Value
[in] Specifies a new value for the variable pointed to by Target.
Return Values
The function returns the initial value pointed to by Target.

Remarks
The functions InterlockedExchange, InterlockedCompareExchange, InterlockedDecrement, InterlockedExchangeAdd, and InterlockedIncrement provide a simple mechanism for synchronizing access to a variable that is shared by multiple threads. The threads of different processes can use this mechanism if the variable is in shared memory.

The variable pointed to by the Target parameter must be aligned on a 32-bit boundary; otherwise, this function will fail on multiprocessor x86 systems and any non-x86 systems.

Requirements
Windows NT/2000: Requires Windows NT 3.5 or later.
Windows 95/98: Requires Windows 95 or later.
Header: Declared in Winbase.h; include Windows.h.
Library: Use Kernel32.lib.

See Also
Synchronization Overview, Synchronization Functions, Interlocked Variable Access, InterlockedCompareExchange, InterlockedDecrement, InterlockedExchangeAdd, InterlockedExchangePointer, InterlockedIncrement

Built on Thursday, October 12, 2000Requirements
Windows NT/2000: Requires Windows NT 3.5 or later.
Windows 95/98: Requires Windows 95 or later.
Header: Declared in Winbase.h; include Windows.h.
Library: Use Kernel32.lib.
See Also
Synchronization Overview, Synchronization Functions, Interlocked Variable Access, InterlockedCompareExchange, InterlockedDecrement, InterlockedExchangeAdd, InterlockedExchangePointer, InterlockedIncrement

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