System.Threading.Interlocked.CompareChange使用

class CompareChange
    {
        private static int i = 0;
        public static System.Threading.AutoResetEvent changeSignal = new System.Threading.AutoResetEvent(false);//同步信号

        public static void test()
        {
            ThreadSafe ts = new ThreadSafe();

            System.Threading.ThreadPool.QueueUserWorkItem((obj) =>
            {
                Console.WriteLine("modifying-thread is waiting for signal");
                CompareChange.changeSignal.WaitOne();
                Console.WriteLine("modifying-thread received the signal");
                CompareChange.i++;
                ts.Total = CompareChange.i;
                Console.WriteLine("modifying-thread modify the CompareChange.i");
                CompareChange.changeSignal.Set();
                Console.WriteLine("modifying-thread send the complete signal");
            });

            System.Threading.ThreadPool.QueueUserWorkItem((obj) =>
            {
                ts.AddToTotal(20);
            });
            
            Console.ReadLine();
        }
    }

    public class ThreadSafe
    {
        // totalValue contains a running total that can be updated 
        // by multiple threads. It must be protected from unsynchronized  
        // access. 
        private int totalValue = 0;
        private int times = 0;
        // The Total property returns the running total. 
        public int Total
        {
            get { return totalValue; }
            set { totalValue = value; }
        }

        // AddToTotal safely adds a value to the running total. 
        public int AddToTotal(int addend)
        {
            int initialValue, computedValue;
            do
            {
                this.times++;
                if (this.times == 2)
                    Console.WriteLine("orignal value has changed.it's the "+this.times.ToString()+"th times to run the process");
                // Save the current running total in a local variable.
                initialValue = totalValue;

                Console.WriteLine("sending the modifying signal");
                CompareChange.changeSignal.Set();

                // Add the new value to the running total.
                computedValue = initialValue + addend;

                Console.WriteLine("waiting for modifying-completely signal");
                CompareChange.changeSignal.WaitOne();

                // CompareExchange compares totalValue to initialValue. If 
                // they are not equal, then another thread has updated the 
                // running total since this loop started. CompareExchange 
                // does not update totalValue. CompareExchange returns the 
                // contents of totalValue, which do not equal initialValue, 
                // so the loop executes again.
            } while (initialValue != System.Threading.Interlocked.CompareExchange(
                ref totalValue, computedValue, initialValue));
            // If no other thread updated the running total, then  
            // totalValue and initialValue are equal when CompareExchange 
            // compares them, and computedValue is stored in totalValue. 
            // CompareExchange returns the value that was in totalValue 
            // before the update, which is equal to initialValue, so the  
            // loop ends. 
            Console.WriteLine("process is over");
            // The function returns computedValue, not totalValue, because 
            // totalValue could be changed by another thread between 
            // the time the loop ends and the function returns. 
            return computedValue;
        }
    }

运行结果：

modifying-thread is waiting for signal
sending the modifying signal
waiting for modifying-completely signal
modifying-thread received the signal
modifying-thread modify the CompareChange.i
modifying-thread send the complete signal
orignal value has changed.it's the 2th times to run the process
sending the modifying signal
waiting for modifying-completely signal
process is over