C# 多线程二：原子操作Interlocked 互锁的理解和简单示例

一.多线程的线程安全

多线程安全问题原因是在cpu执行多线程时，在执行的过程中可能随时切换到其他的线程上执行，当多个线程同时操作同一个变量时，如果不施加其他措施，可能导致错误数据的出现

二.Interlocked的特点

Interlocked是为多个线程共享的变量提供原子操作，这个类是一个静态类 它提供了以线程安全的方式递增、递减、交换和读取值的方法。

它的特点是：
(1)、相对于其他线程同步技术，速度会快很多。（它的原子操作是基于CPU本身的，非阻塞的，所以要比lock的效率高。）

(2)、只能用于简单的同步问题。（数学运算操作仅限于Increment、Decrement以及Add）

三.什么是原子操作

 如果一条语句在底层处理器上被当作一个独立不可分割的指令，那么它本质上是原子的（atomic）。严格的原子性可以阻止任何抢占的可能。对于 32 位（或更低）的字段的简单读写总是原子的。
      而操作 64 位字段仅在 64 位运行时环境下是原子的，并且结合了多个读写操作的语句必然不是原子的.

 32位和64位代表cpu一次处理数据的能力是32位还是64位，由前一章我们所理解的多线程的运行原理 可以轻易的得出当32位机器操作64位字段，如果此时发生了时间片轮询，则此时对64位的操作就不是原子操作

四.Interlocked的方法和作用

Interlocked的方法和作用

方法	作用
CompareExchange()	安全比较两个值是不是相等。如果相等，将第三个值于其中一个值交换
Decrement()	安全递减1,相当于 i--
Exchange()	安全交换：把值2赋给值1；返回新值
Increment()	安全递加1,相当于 i++
Add()	安全相加一个数值,相当于 a = a + 3
Read()	安全读取数值，相等于int a=b

五.Interlocked的简单使用

1.不使用Interlocked

代码：

public class LudwigInterlocked {

    string persion;

    public LudwigInterlocked() {
        persion = "没人啊？";
    }
    public void AddPersion(string name) {
        persion = name;
    }

    public string SubPersion() {
        return persion;
    }
}

class Program {
    static string[] names = new string[] { "小明", "小话", "小雅", "小斌", "小头"};
    static void Main(string[] args) {
        LudwigInterlocked ludwigInterlocked = new LudwigInterlocked();
        ThreadStart threadStart = new ThreadStart(() => {
            for(int i = 0; i < names.Length; i++) {
                ludwigInterlocked.AddPersion(names[i]);
                Thread.Sleep(10);
            }
        });
        Thread thread = new Thread(threadStart);
        thread.Start();
        Thread.Sleep(10);
        Thread thread1 = new Thread(() => {
            for(int i = 0; i < names.Length; i++) {
                string name = ludwigInterlocked.SubPersion();
                if(!string.IsNullOrEmpty(name)) {
                    Console.WriteLine(name);
                    Thread.Sleep(10);
                }
            }
        });
        thread1.Start();

        Console.Read();
    }
}

 打印：

我们发现当两个线程同时操作同一个变量时，出现了我们不想要的结果。

2.使用Interlocked

 代码：

public class LudwigInterlocked {

    string persion;
    long index;
    public LudwigInterlocked() {
        persion = "没人啊？";
    }
    public void AddPersion(string name) {
        while(Interlocked.Read(ref index) == 1) {
            Thread.Sleep(10);
        }
        Interlocked.Increment(ref index);
        persion = name;
    }

    public string SubPersion() {
        while(Interlocked.Read(ref index) == 0) {
            Thread.Sleep(10);
        }
        Interlocked.Decrement(ref index);
        return persion;
    }
}

class Program {
    static string[] names = new string[] { "小明", "小话", "小雅", "小斌", "小头"};
    static void Main(string[] args) {
        LudwigInterlocked ludwigInterlocked = new LudwigInterlocked();
        ThreadStart threadStart = new ThreadStart(() => {
            for(int i = 0; i < names.Length; i++) {
                ludwigInterlocked.AddPersion(names[i]);
                Thread.Sleep(10);
            }
        });
        Thread thread = new Thread(threadStart);
        thread.Start();
        Thread.Sleep(10);
        Thread thread1 = new Thread(() => {
            for(int i = 0; i < names.Length; i++) {
                string name = ludwigInterlocked.SubPersion();
                if(!string.IsNullOrEmpty(name)) {
                    Console.WriteLine(name);
                    Thread.Sleep(10);
                }
            }
        });
        thread1.Start();

        Console.Read();
    }
}

打印：

利用Interlocked达到了我们想要的效果，这个例子中的index使用了Interlocked 进行操作，虽然被多个线程操作，仍然不会出现线程安全的问题。