用简单的C语言实现多任务轮流切换（模拟操作系统线程机制）【转】

本文转载自：http://blog.csdn.net/morixinguan/article/details/50596760

最近在看linux内核的进程调度算法，也写了不少的内核注释，也参考了鸿哥的单片机框架，代码注释就开源在我的CSDN的Git代码库里，有兴趣的可以去瞧瞧。

突发奇想，想到了既然单片机能够实现，那么我用标准C语言同样也可以实现，试了一下，真的可以！！大笑大笑大笑这让我如获至宝！生气

在UNIX和linux还有window中存在着多线程的机制，其实就是把一个任务分成若干个时间片，这样越分越细，执行的效果就好像是在同步在执行，其实这是调度算法在产生效果。如果我们不调用那个所谓的pthread函数，用标准C模拟这样的效果，完全能够做到，可以做到多任务同时执行，从开始到结束，都是同时开始，同时结束。

        废话不多说，我们上代码，看看就知道了:大笑

 

[cpp] view plain copy
 
 print?在CODE上查看代码片派生到我的代码片
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3.   
  4. void  thread_work1(void);  
  5. void  thread_work2(void);   
  6. void  thread_work3(void);  
  7. void  thread_work4(void);  
  8. void  thread_work5(void);  
  9. void  thread_work6(void);  
  10. void  delay(void);  
  11.   
  12. int main(void)  
  13. {  
  14.     static int i = 5 ;  
  15.     static int j ;  
  16.     static int k ;  
  17.     while(1)  
  18.     {  
  19.         printf("---------------第%d次调度开始-----------------\n",++j);  
  20.         putchar('\n');  
  21.         putchar('\n');  
  22.         thread_work1();  
  23.         thread_work2();  
  24.         thread_work3();  
  25.         thread_work4();  
  26.         thread_work5();  
  27.         putchar('\n');  
  28.         putchar('\n');  
  29.         printf("---------------第%d次调度完成-----------------\n",++k);  
  30.         putchar('\n');  
  31.         if(i > 0){  
  32.             i-- ;  
  33.             if(i == 0)  
  34.                 break;   
  35.         }  
  36.     }  
  37.       
  38.     return 0 ;  
  39. }  
  40.   
  41. void thread_work1(void)  
  42. {  
  43.     printf("任务一:\n");  
  44.     delay();  
  45.     static int type = 0;   
  46.     static long int i = 5;  
  47.     printf("i的值:%d\n",i) ;  
  48.     switch(type)  
  49.         {  
  50.             case 0 :   
  51.                    if(i > 0)  
  52.                        i-- ;   
  53.                    printf("type 0 :i=%d\n",i);  
  54.                    type = 1 ;   
  55.                    break ;   
  56.             case 1 :   
  57.                    if(i > 0)  
  58.                     i-- ;  
  59.                     printf("type 1 :i=%d\n",i);  
  60.                    type = 0 ;  
  61.                    break ;  
  62.         }  
  63. }  
  64.   
  65. void thread_work2(void)  
  66. {  
  67.     printf("任务二:\n");  
  68.     delay();  
  69.     static int type = 0 ;   
  70.     static long int i = 5 ;  
  71.     printf("i的值:%d\n",i) ;   
  72.     switch(type)  
  73.     {  
  74.         case 0 :  
  75.                 if(i > 0)  
  76.                     i-- ;  
  77.                 printf("type 0 :i=%d\n",i);  
  78.                 type = 1 ;  
  79.                 break ;  
  80.         case 1 :  
  81.                 if(i > 0)  
  82.                     i-- ;  
  83.                 printf("type 1 :i=%d\n",i);  
  84.                 type = 0 ;   
  85.                 break ;  
  86.     }  
  87. }  
  88.   
  89. void thread_work3(void)  
  90. {  
  91.     printf("任务三:\n");  
  92.     delay();  
  93.     static int type = 0 ;   
  94.     static long int i = 5 ;   
  95.     printf("i的值:%d\n",i) ;  
  96.     switch(type)  
  97.     {  
  98.         case 0 :  
  99.                 if(i > 0)  
  100.                     i-- ;  
  101.                 printf("type 0 :i=%d\n",i);  
  102.                 type = 1 ;  
  103.                 break ;  
  104.         case 1 :  
  105.                 if(i > 0)  
  106.                     i-- ;  
  107.                 printf("type 1 :i=%d\n",i);  
  108.                 type = 0 ;   
  109.                 break ;  
  110.     }  
  111. }  
  112.   
  113. void thread_work4(void)  
  114. {  
  115.     printf("任务四:\n");  
  116.     delay();  
  117.     static int type = 0 ;   
  118.     static long int i = 5;   
  119.     printf("i的值:%d\n",i) ;  
  120.     switch(type)  
  121.     {  
  122.         case 0 :  
  123.                 if(i > 0)  
  124.                     i-- ;  
  125.                 printf("type 0 :i=%d\n",i);  
  126.                 type = 1 ;  
  127.                 break ;  
  128.         case 1 :  
  129.                 if(i > 0)  
  130.                     i-- ;  
  131.                 printf("type 1 :i=%d\n",i);  
  132.                 type = 0 ;   
  133.                 break ;  
  134.     }  
  135. }  
  136.   
  137. void thread_work5(void)  
  138. {  
  139.     printf("任务五:\n");  
  140.     delay();  
  141.     static int type = 0 ;   
  142.     static long int i = 5;   
  143.     printf("i的值:%d\n",i) ;  
  144.     switch(type)  
  145.     {  
  146.         case 0 :  
  147.                 if(i > 0)  
  148.                     i-- ;  
  149.                 printf("type 0 :i=%d\n",i);  
  150.                 type = 1 ;  
  151.                 break ;  
  152.         case 1 :  
  153.                 if(i > 0)  
  154.                     i-- ;  
  155.                 printf("type 1 :i=%d\n",i);  
  156.                 type = 0 ;   
  157.                 break ;  
  158.     }     
  159. }  
  160.   
  161. void delay(void)  
  162. {  
  163.     long int i = 0xffffff ;  
  164.     while(i > 0)  
  165.         i-- ;   
  166. }  

我们看到，上面的5个任务其实是在执行同一个操作，就是将5减到0的操作，一些初学者可能会想，函数不是执行完一个，然后再执行下一个吗?那么我们看看运行结果，这会让你大吃一惊，事实就是这样，不信咱们看看:

 

看到最后的结果，是否觉得很神奇？大笑其实关键就是每个函数里的static这个关键字，它保留了执行完上一次数值的状态，再者就是每个函数中都有一个switch的分支，这样的分支就实现了轮流切换。在我的代码里，该代码经过5次调度完成后，数值从5变为0，而且每一个任务都是实现单独运行，却没有相互干扰，正是这样的机制，运用到单片机和裸板上，这无非就是一种非常好的框架！！！

posted @ 2017-01-30 23:22  请给我倒杯茶  阅读(3241)  评论(0)  编辑  收藏  举报