这两天学习多线程的内容，其中有一个很重要的概念，那就是互锁。当多个线程在运行时需要使用到同一资源，那么就需要使用互锁。例如，提示用户输入一句话，然后一个字一个字的将其打印在屏幕上。那么我们需要一个char类型的变量 char1，两个线程，一个用于对char1赋值，一个用于读取char1的值。，我们设计如下代码来实现上述需求。

1. 
   
2. using System;
   
3. using System.Collections.Generic;
   
4. using System.Text;
   
5. using System.Threading;
   
6. 
   
7. namespace 线程同步interlocked
   
8. {
   
9.     class Program
   
10.     {
    
11.         private static char result;
    
12.         private static string a = "青青子衿，悠悠我心！";
    
13. 
    
14.         static void Main(string[] args)
    
15.         {
    
16.             ThreadStart ts=write;
    
17.             ThreadStart ts2 = read;
    
18.             Thread readThread = new Thread(ts2);
    
19.             Thread writeThread = new Thread(ts);
    
20.             writeThread.Start();
    
21.             readThread.Start();
    
22. 
    
23.         }
    
24.         
    
25.         static void write()
    
26.         {
    
27.             for (int i = 0; i < a.Length; i++)
    
28.             {
    
29.                 result = a[i];
    
30.                 Thread.Sleep(20);
    
31.             }
    
32.         }
    
33.         static void read()
    
34.         {
    
35.             for (int i = 0; i < a.Length; i++)
    
36.             {
    
37.                 char b = result;
    
38.                 Console.Write(b);
    
39.                 Thread.Sleep(20);
    
40.             }
    
41. 
    
42.         }
    
43.     }
    
44. }

复制代码

这样写，貌似没有问题，但是当我们运行程序是就会发现，输出的文字乱七八糟，并不是我们所输入的原文。这是因为两个线程的执行几率并不是完全等分的，那么我们就需要这样来实现，当写入线程在写入的时候，就锁定这个变量，此时不允许读取线程来读取内容，等写完了这个字符，再解锁。同样的，读取线程也是一样。

interlocked类的部分方法
read() 读取计数器的值
Increment() 使计数器增加1
Decrement()使计数器减小1；
Add() 使计数器增加指定的值
Exchange() 把计数器设置为指定的值
CompareExchange()  先把计数器和某个值进行比较，若相等，就把计数器设为指定值



代码如下。

1. using System;
   
2. using System.Collections.Generic;
   
3. using System.Text;
   
4. using System.Threading;
   
5. 
   
6. namespace 线程同步interlocked
   
7. {
   
8.     class Program
   
9.     {
   
10.         private static char result;
    
11.         private static string a = "青青子衿，悠悠我心！";
    
12. 
    
13.         static void Main(string[] args)
    
14.         {
    
15.             ThreadStart ts=write;
    
16.             ThreadStart ts2 = read;
    
17.             Thread readThread = new Thread(ts2);
    
18.             Thread writeThread = new Thread(ts);
    
19.             writeThread.Start();
    
20.             readThread.Start();
    
21. 
    
22.         }
    
23.         static long num = 0; //定义一个long变量用于计数，必须是long，因为interlocked的增加和减少计数器的方法的参数要求是long类型。
    
24.         static void write()
    
25.         {
    
26.             for (int i = 0; i < a.Length; i++)
    
27.             {
    
28.                 while (Interlocked.Read(ref num) == 1) //这里必须使用引用来传递参数，当计数器为1时就不断的让他sleep
    
29.                 { Thread.Sleep(10); }
    
30.                 result = a[i];
    
31.                 Interlocked.Increment(ref num);//写完后就让计数器增加1
    
32.                
    
33.             }
    
34.         }
    
35.         static void read()
    
36.         {
    
37.             for (int i = 0; i < a.Length; i++)
    
38.             {
    
39.                 while (Interlocked.Read(ref num) == 0)
    
40.                 { Thread.Sleep(10); }
    
41.                 char b = result;
    
42.                 Console.Write(b);
    
43.                 Interlocked.Decrement(ref num);//读取完就让计数器减少1
    
44.             }
    
45. 
    
46.         }
    
47.     }
    
48. }
    
49. 
    
50. 
    
51. 
    

复制代码

通过以上代码，我们就可以正常的输出字符串内容了。这里有一个问题，如果我不使用interlocked,而是直接操作num的值，也可以正常输出内容。那么是否这也是一种互锁呢，可是在我学习的资料中，并没有提到我的这种方法。是不是我这种写法并没有实现互锁，只是在这种特定情况下，输出内容正常罢了。知道的同学麻烦告知一下，这里先谢过了。代码是这样写的

1. using System;
   
2. using System.Collections.Generic;
   
3. using System.Text;
   
4. using System.Threading;
   
5. 
   
6. namespace 线程同步interlocked
   
7. {
   
8.     class Program
   
9.     {
   
10.         private static char result;
    
11.         private static string a = "青青子衿，悠悠我心！";
    
12. 
    
13.         static void Main(string[] args)
    
14.         {
    
15.             ThreadStart ts=write;
    
16.             ThreadStart ts2 = read;
    
17.             Thread readThread = new Thread(ts2);
    
18.             Thread writeThread = new Thread(ts);
    
19.             writeThread.Start();
    
20.             readThread.Start();
    
21. 
    
22.         }
    
23.         static long num = 0;
    
24.         static void write()
    
25.         {
    
26.             for (int i = 0; i < a.Length; i++)
    
27.             {
    
28.                 //while (Interlocked.Read(ref num) == 1)
    
29.                 //{ Thread.Sleep(10); }
    
30.                 while (num == 1)
    
31.                 { Thread.Sleep(10); }
    
32.                 result = a[i];
    
33.                 //Interlocked.Increment(ref num);
    
34.                 num += 1;
    
35.             }
    
36.         }
    
37.         static void read()
    
38.         {
    
39.             for (int i = 0; i < a.Length; i++)
    
40.             {
    
41.                 //while (Interlocked.Read(ref num) == 0)
    
42.                 //{ Thread.Sleep(10); }
    
43.                 while (num == 0)
    
44.                 { Thread.Sleep(10); }
    
45.                 char b = result;
    
46.                 Console.Write(b);
    
47.                 num = num - 1;
    
48.                 //Interlocked.Decrement(ref num);
    
49.             }
    
50. 
    
51.         }
    
52.     }
    
53. }

复制代码

num 最后那个中实现  
也就是直接操作num的值
直接操作NUM是在内存中进行操作
InterLocked.Increment 是在 CPU寄存器内操作
InterLocked.Increment 区别在于 你开两个进程   
能通过寄存器同步 ,而 直接操作NUM是在内存中操作
开两个进程 他们在内存中生成的NUM变量是无法共享的

1. Interlocked类的成员来实现线程同步；
2. Interlocked类提供了同步对多个线程共享的变量的访问的方法；
3. Interlocked类提供了Increment和Decrement方法递增或递减某个变量并返回结果；
4. 如果我不使用interlocked,而是直接操作num的值可能会发生死锁；
5. 直接操作num只不过是通过设置标志位来判断线程间实现同步，一旦线程较多，程序会崩溃。