using System; 
using System.Threading;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

public sealed class Program 
{
    public static void Main() 
    {
        const Int32 count = 200 * 1000 * 1000; // 200,000,000 iterations
        Stopwatch sw;

        sw = Stopwatch.StartNew();
        for (int n = 0; n < count; n++) M();
        Console.WriteLine(sw.Elapsed + "\tM");

        sw = Stopwatch.StartNew();
        for (int n = 0; n < count; n++) Thread.SpinWait(1);
        Console.WriteLine(sw.Elapsed + "\tSpinWait");

        sw = Stopwatch.StartNew();
        for (int n = 0; n < count; /*n++*/) n++;
        Console.WriteLine(sw.Elapsed + "\t++");

        sw = Stopwatch.StartNew();
        for (int n = 0; n < count; /*n++*/) Interlocked.Increment(ref n);
        Console.WriteLine(sw.Elapsed + "\tIncrement");

        sw = Stopwatch.StartNew();
        for (int n = 0; n < count; n++) SwitchToThread();
        Console.WriteLine(sw.Elapsed + "\tSwitchToThread");

        sw = Stopwatch.StartNew();
        for (int n = 0; n < count; n++) Thread.Sleep(0);
        Console.WriteLine(sw.Elapsed + "\tSleep");

        using(WaitHandle h = new ManualResetEvent(false))
        {
            sw = Stopwatch.StartNew();
            for (int n = 0; n < count; n++) h.WaitOne(0, false);
            Console.WriteLine(sw.Elapsed + "\tWaitOne");
        }

        Console.WriteLine("Hit Enter");
        Console.ReadLine();
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    private static void M() { }

    [DllImport("Kernel32", ExactSpelling = true)]
    private static extern Boolean SwitchToThread();
}

public static class InterlockedEx 
{
    public static Int32 And(ref Int32 target, Int32 with) 
    {
        Int32 startVal, currentVal = target;

        // Don't access target in the loop except in an attempt 
        // to change it because another thread may be touching it 
        do 
        {
            // Record this iteration's starting value
            startVal = currentVal;

            // Calculate the desired value (this example ANDs the bits)
            Int32 desiredVal = startVal & with;

            // NOTE: The thread could be pre-empted here

            // if (target == startVal) target = desiredVal;
            // Value prior to potential change is returned
            currentVal = Interlocked.CompareExchange(
                ref target, desiredVal, startVal);

            // If the starting value changed during this iteration, repeat 
        } 
        while (startVal != currentVal);

        // Return this iteration's starting value
        return currentVal;
    }
}

public class UseSomeResource {
    private SpinWaitLock m_swl = new SpinWaitLock();

    public void AccessResource() {
        try 
        {
            m_swl.Enter();
            // Access the resource...
        }
        finally {
            m_swl.Exit();
        }
    }
}

// NOTE: This is a value type so it works very efficiently when used as
// a field in a class. Avoid boxing this or you will lose thread safety!
public struct SpinWaitLock
{
    private const Int32 c_lsFree = 0;
    private const Int32 c_lsOwned = 1;
    private Int32 m_LockState; // Defaults to 0=c_lsFree

    public void Enter() 
    {
        Thread.BeginCriticalRegion();
        while (true) 
        {
            // If resource available, set it to in-use and return
            if (Interlocked.Exchange(
                ref m_LockState, c_lsOwned) == c_lsFree) 
            {
                return;
            }

            // Efficiently spin, until the resource looks like it might 
            // be free. NOTE: Just reading here (as compared to repeatedly 
            // calling Exchange) improves performance because writing 
            // forces all CPUs to update this value
            while (Thread.VolatileRead(ref m_LockState) == c_lsOwned) 
            {
               StallThread();
            }
        }
    }

    public void Exit() 
    { 
        // Mark the resource as available
        Interlocked.Exchange(ref m_LockState, c_lsFree);
        Thread.EndCriticalRegion();
    }

    private static readonly Boolean IsSingleCpuMachine =
        (Environment.ProcessorCount == 1);

    private static void StallThread() 
    {
        // On a single-CPU system, spinning does no good
        if (IsSingleCpuMachine) SwitchToThread();
      
        // Multi-CPU system might be hyper-threaded, let other thread run
        else Thread.SpinWait(1);
    }

    [DllImport("kernel32", ExactSpelling=true)]
    private static extern void SwitchToThread();
}