internal class SpinLockDemo2
    {
        private const int N = 10000000;
        private static Queue<Data> _queue = new Queue<Data>();
        static ConcurrentQueue<Data> _concurrentQueue = new ConcurrentQueue<Data>();
        private static object _lock = new Object();
        private static SpinLock _spinlock = new SpinLock();

        private class Data
        {
            public string Name { get; set; }
            public double Number { get; set; }
        }

        public static void Start(string[] args)
        {
            UseLock();
            _queue = new Queue<Data>();
            GC.Collect();
            GC.WaitForFullGCComplete();
            GC.Collect();
            UseSpinLock();
            GC.Collect();
            GC.WaitForFullGCComplete();
            GC.Collect();
            UseConcurrentLock();

            Console.WriteLine("Press a key");
            Console.ReadKey();
        }

        private static void UpdateWithSpinLock(Data d, int i)
        {
            bool lockTaken = false;
            try
            {
                _spinlock.Enter(ref lockTaken);
                _queue.Enqueue(d);
            }
            finally
            {
                if (lockTaken) _spinlock.Exit(false);
            }
        }

        private static void UseSpinLock()
        {

            Stopwatch sw = Stopwatch.StartNew();

            Parallel.For(1, 4,
                         i2 =>
                             {
                                 for (int i = 0; i < N; i++)
                                 {
                                     UpdateWithSpinLock(new Data() {Name = i.ToString(), Number = i}, i);
                                 }
                             });
                
            sw.Stop();
            Console.WriteLine("elapsed ms with spinlock: {0}", sw.ElapsedMilliseconds);
        }

        private static void UpdateWithLock(Data d, int i)
        {
            lock (_lock)
            {
                _queue.Enqueue(d);
            }
        }
        private static void UpdateConcurrent(Data d, int i)
        {
           _concurrentQueue.Enqueue(d);
        }
        private static void UseLock()
        {
            Stopwatch sw = Stopwatch.StartNew();
            Parallel.For(1, 4,
                                   i2 =>
                                   {
                                       for (int i = 0; i < N; i++)
                                       {
                                           UpdateWithLock(new Data() { Name = i.ToString(), Number = i }, i);
                                       }
                                   });
            sw.Stop();
            Console.WriteLine("elapsed ms with lock: {0}", sw.ElapsedMilliseconds);
        }
        private static void UseConcurrentLock()
        {
            Stopwatch sw = Stopwatch.StartNew();
            Parallel.For(1, 4,
                                   i2 =>
                                   {
                                       for (int i = 0; i < N; i++)
                                       {
                                           UpdateConcurrent(new Data() { Name = i.ToString(), Number = i }, i);
                                       }
                                   });
            sw.Stop();
            Console.WriteLine("elapsed ms with concurrent: {0}", sw.ElapsedMilliseconds);
        }

    }

            // стартуем с одновременным измененем флага
            if (Interlocked.CompareExchange(ref fThreadFlag, 1, 0) == 0)
                fThread.Start();

            // стопаем с одновременным измененем флага
            if (Interlocked.CompareExchange(ref fThreadFlag, 0, 1) == 1)
                _exitBytimeout = !fThread.Join(JoinTimeout);

            // в цикле осуществляется вызов бизнес-функции 
            while (Interlocked.CompareExchange(ref fThreadFlag, 0, 0) == 1)
            {
                if (_isAllowed())
                    PWorkFunction();
            }