C#线程：线程池和文件下载服务器

虽然线程可以在一定程度上提高程序运行的效率，但也会产生一些副作用。让我们先看看如下的代码：

创新互联专注于新城企业网站建设,成都响应式网站建设公司,商城开发。新城网站建设公司,为新城等地区提供建站服务。全流程按需求定制设计，专业设计，全程项目跟踪，创新互联专业和态度为您提供的服务

 
 
 
    
  
  
  
  1. class Increment 
    2. 
  
  
  
  2.   { 
    3. 
  
  
  
  3.       private int n = 0; 
    4. 
  
  
  
  4.       private int max; 
    5. 
  
  
  
  5.       public Increment(int max) 
    6. 
  
  
  
  6.       { 
    7. 
  
  
  
  7.           this.max = max; 
    8. 
  
  
  
  8.       } 
    9. 
  
  
  
  9.       public int result 
    10. 
  
  
  
  10.       { 
    11. 
  
  
  
  11.           get
    12. 
  
  
  
  12.           { 
    13. 
  
  
  
  13.               return n; 
    14. 
  
  
  
  14.           } 
    15. 
  
  
  
  15.           set
    16. 
  
  
  
  16.           { 
    17. 
  
  
  
  17.               n = value; 
    18. 
  
  
  
  18.           } 
    19. 
  
  
  
  19.       } 
    20. 
  
  
  
  20.       public void Inc() 
    21. 
  
  
  
  21.       {             
    22. 
  
  
  
  22.           for (int i = 0; i <  max; i++) 
    23. 
  
  
  
  23.           { 
    24. 
  
  
  
  24.               n++; 
    25. 
  
  
  
  25.           } 
    26. 
  
  
  
  26.       } 
    27. 
  
  
  
  27.   } 
    28. 
  
  
  
  28.   class Program 
    29. 
  
  
  
  29.   { 
    30. 
  
  
  
  30.       public static void Main() 
    31. 
  
  
  
  31.       { 
    32. 
  
  
  
  32.           Increment inc = new Increment(10000); 
    33. 
  
  
  
  33.           Thread[] threads = new Thread[30]; 
    34. 
  
  
  
  34.           for (int i = 0; i <  threads.Length; i++) 
    35. 
  
  
  
  35.           { 
    36. 
  
  
  
  36.               threads[i] = new Thread(inc.Inc); 
    37. 
  
  
  
  37.               threads[i].Start(); 
    38. 
  
  
  
  38.           } 
    39. 
  
  
  
  39.           for (int i = 0; i <  threads.Length; i++) 
    40. 
  
  
  
  40.           { 
    41. 
  
  
  
  41.               threads[i].Join();  // 等待30个线程都执行完 
    42. 
  
  
  
  42.           } 
    43. 
  
  
  
  43.           Console.WriteLine(inc.result);  //输出n的值 
    44. 
  
  
  
  44. 
  
  
  
  45.       } 
    46. 
  
  
  
  46. 
  
  
  
  47.   } 
    48.

上面的程序的基本功能是使用Increment的Inc方法为n递增max，所不同的是，将在Main方法中启动30个线程同时执行Inc方法。在本例中max的值是10000（通过Increment的构造方法传入）。读者可以运行一下这个程序，正常的结果应该是300000，但通常不会得到这个结果，一般获得的结果都比300000小。其中的原因就是Inc方法中的n++上，虽然从表面上看，n++只是一条简单的自增语言，但从底层分析，n++的IL代码如下：

 
 
 
    
  
  
  
  1. ldsfld // 获得n的初始值，并压到方法栈中 
    2. 
  
  
  
  2. 
  
  
  
  3. ldc.i4.1 // 将1压到方法栈中 
    4. 
  
  
  
  4. 
  
  
  
  5. add // 从方法栈中弹出最顶端的两个值，相加，然后将结果保存在方法栈中 
    6. 
  
  
  
  6. 
  
  
  
  7. stfld // 从当前方法栈中弹出一个值，并更新类字段n 
    8. 
  
  
  
  8.

对于上面每一条IL语句是线程安全的，但是n++这条C#语句需要上面的四步才能完成，因此，n++这条语句并不是线程安全的。只要在执行stfld指令之前的任何一步由于其他线程获得CPU而中断，那么就会出现所谓的“脏”数据。

假设n的初始值为0， 在thread1在执行完ldc.i4.1后被thread2中断（add指令并未执行），这时thread2获得的n的初始值仍然是0，假设thread2顺利执行完，那么这时n的值已经是1了，当thread2执行完后，thread1继续执行add指令，并且thread1也顺利执行完，这时，在thread1中的执行结果n仍然是1。因此，这也就出现了调用两次n++，n仍然为1的情况。要解决这个问题的方法也很容易想到，就是让上述四条IL语句要不都不执行，要执行就都执行完，这有点事务处理的意思。

在C#线程中解决这个问题的技术叫同步。同步的本质就是为某一个代码块加锁，使其成为一个整体，共同进退。最简单的是使用lock为代码块加锁。这个语句在前几讲已经多次使用过了。lock语句可以锁定任何的对象，如果锁定的是类成员，直接使用lock(obj)的形式即可，如果锁定的是静态成员，可以把锁主在object类型上，代码如下：

 
 
 
    
  
  
  
  1. lock(typeof(StaticClass)) 
    2. 
  
  
  
  2. 
  
  
  
  3. { 
    4. 
  
  
  
  4. 
  
  
  
  5.    ... ... 
    6. 
  
  
  
  6. 
  
  
  
  7. } 
    8. 
  
  
  
  8.

对于Increment类，我们可以锁定n++，也可以锁定Inc方法，如锁定n++的Increment类的代码如下：

 
 
 
    
  
  
  
  1. class Increment 
    2. 
  
  
  
  2.  { 
    3. 
  
  
  
  3.      private int n = 0; 
    4. 
  
  
  
  4.      private int max; 
    5. 
  
  
  
  5.      private Object lockN = new Object(); 
    6. 
  
  
  
  6.      public Increment(int max) 
    7. 
  
  
  
  7.      { 
    8. 
  
  
  
  8.          this.max = max; 
    9. 
  
  
  
  9.      } 
    10. 
  
  
  
  10.      public int result 
    11. 
  
  
  
  11.      { 
    12. 
  
  
  
  12.          get
    13. 
  
  
  
  13.          { 
    14. 
  
  
  
  14.              return n; 
    15. 
  
  
  
  15.          } 
    16. 
  
  
  
  16.          set
    17. 
  
  
  
  17.          { 
    18. 
  
  
  
  18.              n = value; 
    19. 
  
  
  
  19.          } 
    20. 
  
  
  
  20.      } 
    21. 
  
  
  
  21. 
  
  
  
  22.      private void IncN() 
    23. 
  
  
  
  23.      { 
    24. 
  
  
  
  24.          lock (lockN) 
    25. 
  
  
  
  25.          { 
    26. 
  
  
  
  26.              n++; 
    27. 
  
  
  
  27.          } 
    28. 
  
  
  
  28.      } 
    29. 
  
  
  
  29.      public void Inc() 
    30. 
  
  
  
  30.      { 
    31. 
  
  
  
  31.          for (int i = 0; i <  max; i++) 
    32. 
  
  
  
  32.          { 
    33. 
  
  
  
  33.                IncN(); 
    34. 
  
  
  
  34.          }            
    35. 
  
  
  
  35.      } 
    36. 
  
  
  
  36.  } 
    37.

也可以直接将如下的代码放到for循环中取代调用IncN方法，

 
 
 
    
  
  
  
  1. lock (lockN) 
    2. 
  
  
  
  2.  { 
    3. 
  
  
  
  3.      n++; 
    4. 
  
  
  
  4.  } 
    5.

或者直接将Inc方法锁住，代码如下：

 
 
 
    
  
  
  
  1. public void Inc() 
    2. 
  
  
  
  2.  { 
    3. 
  
  
  
  3.      lock (lockN) 
    4. 
  
  
  
  4.      { 
    5. 
  
  
  
  5.          for (int i = 0; i <  max; i++) 
    6. 
  
  
  
  6.          { 
    7. 
  
  
  
  7.              n++; 
    8. 
  
  
  
  8.          } 
    9. 
  
  
  
  9.      } 
    10. 
  
  
  
  10.  } 
    11.

但笔者并不建议直接将Inc锁住，因为这样就和单线程没什么区别了，虽然可以避免出现读脏数据的情况，但却牺牲的效率。

从本例分析得知，产生问题的原因就是因为n++不是原子操作。而在.net framework中提供了一个Interlocked类，可以使n++变成原子操作。Interlocked有一些方法，可以保证对变量的操作是原子的，如Increment方法保证n++的操作是原子的，Decrement方法保证n--的操作是原子的，Exchange方法保证为变量赋值的操作是原子的。因此，可以使用Increment方法来替换n++，代码如下：

 
 
 
    
  
  
  
  1. public void Inc() 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.     for (int i = 0; i <  max; i++) 
    4. 
  
  
  
  4.     { 
    5. 
  
  
  
  5.         Interlocked.Increment(ref n); 
    6. 
  
  
  
  6.     } 
    7. 
  
  
  
  7. } 
    8. 
  
  
  
  8.

任何事物都具有两面性，同步技术也不例外，在某些情况下，可以由于两个线程互相锁定某些对象而造成死锁（就是两个线程互相等待对方释放对象）。这就象有两个学生晚上在复习功课，他们都希望学习能超过对方，而且他们都很累了，但是谁也不肯先休息，是都在盯着对方屋里的灯，期望着对方休息后。自己才休息。但却谁也不肯先关灯，所以他们就只有这样耗到天亮了。当然，解决这个问题的方法有两个，***个就是其中一个学生或两个学生根本就不关心对方是否先睡觉，自己学累了就直接关灯了。当然，另外一个方法就有点暴力了，就是到点就直接断电，那谁也别学了（这也相当于线程中断，不过不到万不得以时***别用这招）。

让我们先举一个线程死锁的例子，代码如下：

 
 
 
    
  
  
  
  1. class Program 
    2. 
  
  
  
  2.  { 
    3. 
  
  
  
  3.      private static Object objA = new Object(); 
    4. 
  
  
  
  4.      private static Object objB = new Object(); 
    5. 
  
  
  
  5.      public static void LockA() 
    6. 
  
  
  
  6.      { 
    7. 
  
  
  
  7.          lock (objA) 
    8. 
  
  
  
  8.          { 
    9. 
  
  
  
  9.              Thread.Sleep(1000); 
    10. 
  
  
  
  10.              lock (objB) 
    11. 
  
  
  
  11.              { 
    12. 
  
  
  
  12.              } 
    13. 
  
  
  
  13.          } 
    14. 
  
  
  
  14.          Console.WriteLine("LockA"); 
    15. 
  
  
  
  15.      } 
    16. 
  
  
  
  16.      public static void LockB() 
    17. 
  
  
  
  17.      { 
    18. 
  
  
  
  18.          lock (objB) 
    19. 
  
  
  
  19.          { 
    20. 
  
  
  
  20.              Thread.Sleep(2000); 
    21. 
  
  
  
  21.              lock (objA) 
    22. 
  
  
  
  22.              { 
    23. 
  
  
  
  23.              } 
    24. 
  
  
  
  24.          } 
    25. 
  
  
  
  25.          Console.WriteLine("LockB"); 
    26. 
  
  
  
  26.      } 
    27. 
  
  
  
  27.      public static void Main() 
    28. 
  
  
  
  28.      { 
    29. 
  
  
  
  29.          Thread threadA = new Thread(LockA); 
    30. 
  
  
  
  30.          Thread threadB = new Thread(LockB); 
    31. 
  
  
  
  31.          threadA.Start(); 
    32. 
  
  
  
  32.          threadB.Start(); 
    33. 
  
  
  
  33.      } 
    34. 
  
  
  
  34.  } 
    35.

在上面的代码中，LockA方法会在当前线程中执行完Lock(objA)后延迟1秒，而LockB方法会在执行完lock(objB)后延迟2秒，一般LockA会先执行lock(objB），但这时objB已经被LockB锁住了，而且LockB还在延迟（2秒还没到）。在这时，LockA已经将objA和objB都锁上了，当LockB执行到lock(objA)时，由于objA已经被锁上，因此，LockB就被阻塞了。而LockA在执行到lock(objB）时，由于这时LockA还在延迟，因此，objB也被锁住了。LockA和LockB也就相当于上述的两个学生，互相等待对方关灯，但谁也不肯先关灯，所以就死锁了。如果采用***种方法非常简单，就是保持被锁定的多个对象的顺序，如将LockB方法的锁定顺序换一下，代码如下：

 
 
 
    
  
  
  
  1. public static void LockB() 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.     lock (objA) 
    4. 
  
  
  
  4.     { 
    5. 
  
  
  
  5.          Thread.Sleep(2000); 
    6. 
  
  
  
  6.           lock (objB) 
    7. 
  
  
  
  7.           { 
    8. 
  
  
  
  8.           } 
    9. 
  
  
  
  9.     } 
    10. 
  
  
  
  10.     Console.WriteLine("LockB"); 
    11. 
  
  
  
  11. } 
    12. 
  
  
  
  12.

或是将LockA方法也改一下，先锁objB，再锁objA。

当然，也可以采用暴力一点的方法，当发现一些线程长时间没反应时，可以使用Abort方法强行中断它们。代码如下：

 
 
 
    
  
  
  
  1. public static void Main() 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.      Thread threadA = new Thread(LockA); 
    4. 
  
  
  
  4.      Thread threadB = new Thread(LockB); 
    5. 
  
  
  
  5.      threadA.Start(); 
    6. 
  
  
  
  6.      threadB.Start(); 
    7. 
  
  
  
  7. 
  
  
  
  8.      Thread.Sleep(4000); 
    9. 
  
  
  
  9. 
  
  
  
  10.      threadA.Abort(); 
    11. 
  
  
  
  11.      threadB.Abort(); 
    12. 
  
  
  
  12.      Console.WriteLine("线程全部结束"); 
    13. 
  
  
  
  13. } 
    14. 
  
  
  
  14.

在后面的文章中将讲解C#线程中其他的同步技术。

网站名称：C#线程：线程池和文件下载服务器
文章来源：http://www.shufengxianlan.com/qtweb/news16/171566.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

动态网站知识

同城分类信息

邛崃网站建设　　 　香港空间腾讯云　　 　网络营销推广　　 　宣威网站建设　　 　云服务器　　 　LED显示屏　　 　做移动网站　　 　成都微信二次开发　　 　成都SEO优化公司　　 　四川胜锦安防　　 　手机网站制作设计　　 　托管服务器　　 　四川门窗　　 　成都网站建设　　 　成都网站设计　　 　东电技改　　 　网站推广　　 　网站营销　　 　简阳服务器托管　　 　短视频拍摄