一个多线程的简单例子让你看清线程调度的随机性

线程调度的几个基本知识点

专注于为中小企业提供成都网站设计、网站建设服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业丰南免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了上1000家企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。

多线程并发执行时有很多同学捋不清楚调度的随机性会导致哪些问题，要知道如果访问临界资源不加锁会导致一些突发情况发生甚至死锁。

关于线程调度，需要深刻了解以下几个基础知识点：

调度的最小单位是轻量级进程【比如我们编写的hello world最简单的C程序，执行时就是一个轻量级进程】或者线程;

每个线程都会分配一个时间片，时间片到了就会执行下一个线程;

线程的调度有一定的随机性，无法确定什么时候会调度;

在同一个进程内，创建的所有线程除了线程内部创建的局部资源，进程创建的其他资源所有线程共享;比如：主线程和子线程都可以访问全局变量，打开的文件描述符等。

实例

再多的理论不如一个形象的例子来的直接。

预期代码时序

假定我们要实现一个多线程的实例，预期程序执行时序如下：

期待时序

期待的功能时序：

  1. 主进程创建子线程，子线程函数function();
  2. 主线程count自加，并分别赋值给value1,value2;
  3. 时间片到了后切换到子线程，子线程判断value1、value2值是否相同，如果不同就打印信息value1,value2,count的值，但是因为主线程将count先后赋值给了value1,value2，所以value1,value2的值应该永远不相同，所以不应该打印任何内容;
  4. 重复2、3步骤。

代码1

好了，现在我们按照这个时序编写代码如下：

 
 
 
 
    
  
  
  
  
  1. 1 #include  
    2.   
  
  
  
  2.   2 #include  
    3.   
  
  
  
  3.   3 #include  
    4.   
  
  
  
  4.   4 #include  
    5.   
  
  
  
  5.   5 #include  
    6.   
  
  
  
  6.   6  
    7.   
  
  
  
  7.   7 unsigned int value1,value2, count=0; 
    8.   
  
  
  
  8.   8 void *function(void *arg); 
    9.   
  
  
  
  9.   9 int main(int argc,  char *argv[]) 
    10.   
  
  
  
  10.  10 { 
    11.   
  
  
  
  11.  11     pthread_t  a_thread; 
    12.   
  
  
  
  12.  12  
    13.   
  
  
  
  13.  13     if (pthread_create(&a_thread, NULL, function, NULL) < 0) 
    14.   
  
  
  
  14.  14     { 
    15.   
  
  
  
  15.  15         perror("fail to pthread_create"); 
    16.   
  
  
  
  16.  16         exit(-1); 
    17.   
  
  
  
  17.  17     } 
    18.   
  
  
  
  18.  18     while ( 1 ) 
    19.   
  
  
  
  19.  19     { 
    20.   
  
  
  
  20.  20         count++; 
    21.   
  
  
  
  21.  21         value1 = count; 
    22.   
  
  
  
  22.  22         value2 = count; 
    23.   
  
  
  
  23.  23     } 
    24.   
  
  
  
  24.  24     return 0; 
    25.   
  
  
  
  25.  25 } 
    26.   
  
  
  
  26.  26  
    27.   
  
  
  
  27.  27 void  *function(void *arg) 
    28.   
  
  
  
  28.  28 { 
    29.   
  
  
  
  29.  29     while ( 1 ) 
    30.   
  
  
  
  30.  30     { 
    31.   
  
  
  
  31.  31         if (value1 != value2) 
    32.   
  
  
  
  32.  32         {                                                                                                                                                                                          
    33.   
  
  
  
  33.  33             printf("count=%d , value1=%d, value2=%d\n",  count, value1, value2); 
    34.   
  
  
  
  34.  34             usleep(100000); 
    35.   
  
  
  
  35.  35         }      
    36.   
  
  
  
  36.  36     } 
    37.   
  
  
  
  37.  37     return  NULL; 
    38.   
  
  
  
  38.  38 }   
    39.

乍一看，该程序应该可以满足我们的需要，并且程序运行的时候不应该打印任何内容，但是实际运行结果出乎我们意料。

编译运行：

 
 
 
 
    
  
  
  
  
  1. gcc test.c -o run -lpthread 
    2.   
  
  
  
  2. ./run 
    3.

代码1执行结果

执行结果：

可以看到子程序会随机打印一些信息，为什么还有这个执行结果呢?其实原因很简单，就是我们文章开头所说的，线程调度具有䘺随机性，我们无法规定让内核何时调度某个线程。有打印信息，那么这说明此时value1和value2的值是不同的，那也说明了调度子线程的时候，是在主线程向value1和value2之间的位置调度的。

代码1执行的实际时序

实际上代码的执行时序如下所示：

如上图，在某一时刻，当程序走到**value2 = count;**这个位置的时候，内核对线程进行了调度，于是子进程在判断value1和value2的值的时候，发现这两个变量值不相同，就有了打印信息。

该程序在下面这两行代码之间调度的几率还是很大的。

 
 
 
 
    
  
  
  
  
  1. value1 = count;  
    2.   
  
  
  
  2. value2 = count; 
    3.

解决方法

如何来解决并发导致的程序没有按预期执行的问题呢?对于线程来说，常用的方法有posix信号量、互斥锁，条件变量等，下面我们以互斥锁为例，讲解如何避免代码1的问题的出现。

互斥锁的定义和初始化：

 
 
 
 
    
  
  
  
  
  1. pthread_mutex_t  mutex; 
    2.   
  
  
  
  2. pthread_mutex_init(&mutex, NULL) 
    3.

申请释放锁：

 
 
 
 
    
  
  
  
  
  1. pthread_mutex_lock(&mutex); 
    2.   
  
  
  
  2. pthread_mutex_unlock(&mutex); 
    3.

原理：进入临界区之前先申请锁，如果能获得锁就继续往下执行， 如果申请不到，就休眠，直到其他线程释放该锁为止。

代码2

 
 
 
 
    
  
  
  
  
  1. 1 #include  
    2.   
  
  
  
  2.  2 #include  
    3.   
  
  
  
  3.  3 #include  
    4.   
  
  
  
  4.  4 #include  
    5.   
  
  
  
  5.  5 #include  
    6.   
  
  
  
  6.  6 #define _LOCK_ 
    7.   
  
  
  
  7.  7 unsigned int value1,value2, count=0; 
    8.   
  
  
  
  8.  8 pthread_mutex_t  mutex; 
    9.   
  
  
  
  9.  9 void *function(void *arg); 
    10.   
  
  
  
  10. 10  
    11.   
  
  
  
  11. 11 int main(int argc,  char *argv[]) 
    12.   
  
  
  
  12. 12 { 
    13.   
  
  
  
  13. 13     pthread_t  a_thread; 
    14.   
  
  
  
  14. 14           
    15.   
  
  
  
  15. 15     if (pthread_mutex_init(&mutex, NULL) < 0)                                                                                                                                                           
    16.   
  
  
  
  16. 16     { 
    17.   
  
  
  
  17. 17         perror("fail to mutex_init"); 
    18.   
  
  
  
  18. 18         exit(-1); 
    19.   
  
  
  
  19. 19     } 
    20.   
  
  
  
  20. 20  
    21.   
  
  
  
  21. 21     if (pthread_create(&a_thread, NULL, function, NULL) < 0) 
    22.   
  
  
  
  22. 22     { 
    23.   
  
  
  
  23. 23         perror("fail to pthread_create"); 
    24.   
  
  
  
  24. 24         exit(-1); 
    25.   
  
  
  
  25. 25     } 
    26.   
  
  
  
  26. 26     while ( 1 ) 
    27.   
  
  
  
  27. 27     { 
    28.   
  
  
  
  28. 28         count++; 
    29.   
  
  
  
  29. 29 #ifdef  _LOCK_ 
    30.   
  
  
  
  30. 30         pthread_mutex_lock(&mutex); 
    31.   
  
  
  
  31. 31 #endif 
    32.   
  
  
  
  32. 32         value1 = count; 
    33.   
  
  
  
  33. 33         value2 = count; 
    34.   
  
  
  
  34. 34 #ifdef  _LOCK_ 
    35.   
  
  
  
  35. 35         pthread_mutex_unlock(&mutex); 
    36.   
  
  
  
  36. 36 #endif 
    37.   
  
  
  
  37. 37     } 
    38.   
  
  
  
  38. 38     return 0; 
    39.   
  
  
  
  39. 39  } 
    40.   
  
  
  
  40. 0  
    41.   
  
  
  
  41. 41 void  *function(void *arg) 
    42.   
  
  
  
  42. 42 { 
    43.   
  
  
  
  43. 43      while ( 1 ) 
    44.   
  
  
  
  44. 44      { 
    45.   
  
  
  
  45. 45 #ifdef _LOCK_ 
    46.   
  
  
  
  46. 46         pthread_mutex_lock(&mutex); 
    47.   
  
  
  
  47. 47 #endif            
    48.   
  
  
  
  48. 48  
    49.   
  
  
  
  49. 49         if (value1 != value2)   
    50.   
  
  
  
  50. 50         { 
    51.   
  
  
  
  51. 51             printf("count=%d , value1=%d, value2=%d\n",  count, value1, value2); 
    52.   
  
  
  
  52. 52             usleep(100000); 
    53.   
  
  
  
  53. 53         }      
    54.   
  
  
  
  54. 54 #ifdef _LOCK_ 
    55.   
  
  
  
  55. 55         pthread_mutex_unlock(&mutex); 
    56.   
  
  
  
  56. 56 #endif 
    57.   
  
  
  
  57. 57      } 
    58.   
  
  
  
  58. 58      return  NULL; 
    59.   
  
  
  
  59. 59  }      
    60.

如上述代码所示:主线程和子线程要访问临界资源value1,value2时，都必须先申请锁，获得锁之后才可以访问临界资源，访问完毕再释放互斥锁。该代码执行之后就不会打印任何信息。我们来看下，如果程序在下述代码之间产生调度时，程序的时序图。

 
 
 
 
    
  
  
  
  
  1. value1 = count;  
    2.   
  
  
  
  2. value2 = count; 
    3.

时序图如下：

如上图所示：

  1. 时刻n，主线程获得mutex，从而进入临界区;
  2. 时刻n+1，时间片到了，切换到子线程;
  3. n+2时刻子线程申请不到锁mutex，所以放弃cpu，进入休眠;
  4. n+3时刻，主线程释放mutex，离开临界区，并唤醒阻塞在mutex的子线程，子线程申请到mutex，进入临界区;
  5. n+4时刻，子线程离开临界区，释放mutex。

可以看到，加锁之后，即使主线程在value2 =count; 之前产生了调度，子线程由于获取不到mutex，会进入休眠，只有主线程出了临界区，子线程才能获得mutex，访问value1和value2,就永远不会打印信息，就实现了我们预期的代码时序。

总结

实际项目中，可能程序的并发的情况可能会更加复杂，比如多个cpu上运行的任务之间，cpu运行的任务和中断之间，中断和中断之间，都有可能并发。

有些调度的概率虽然很小，但是不代表不发生，而且由于资源同步互斥导致的问题，很难复现，纵观Linux内核代码，所有的临界资源都会对应锁。

多阅读Linux内核源码，学向大神学习，与大神神交。

正所谓代码读百遍，其义自见!熟读代码千万行，不会编写也会抄!

关于内核和应用程序的同步互斥的知识点，可以查看一口君的其他文章。

本文转载自微信公众号「一口Linux」，可以通过以下二维码关注。转载本文请联系一口Linux公众号。

分享名称：一个多线程的简单例子让你看清线程调度的随机性
文章路径：http://www.mswzjz.com/qtweb/news4/186154.html

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

广告

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

猜你还喜欢下面的内容

网站收录知识

分类信息网站

混凝土密封固化剂　　 　亮美家　　 　德阳定制网站建设　　 　成都网站制作　　 　东电技服　　 　seo关键词优化　　 　广安园林景观设计　　 　主机租用　　 　成都服务器机柜租用　　 　成都小程序开发　　 　成都h5网站建设　　 　四川广汉锦华　　 　重庆联通机房托管　　 　鼎尚理发店　　 　品牌网站建设　　 　成都定制高级网站建设　　 　网络营销推广　　 　外贸网站建设　　 　成都网站推广　　 　营销推广