[RTT例程练习] 2.1 问题引入 线程抢占导致的临界区问题 .

这一小节是只是一个演示问题的实验。

在编程中，时常会碰到全局变量，程序在不同的地方都可以对全局变量进行修改，引起很大的麻烦。在RTOS中，尤其如此。因为不同的线程都有可能修改一个全局变量，而修改的顺序确实由调度决定的，不能通过人力决定。

当然，这个问题不是只限于全局变量。例如两个线程都可以通过串口向终端打印信息。如果没有一种控制机制，两个线程打印的信息就会交织在一起。

下面这段程序只是演示了这个现象。两个线程同时对一个变量+1。

程序

 

[cpp] view plaincopyprint?
  1. #include <rtthread.h>   
  2.   
  3. static rt_uint32_t share_var;  
  4.   
  5. static char thread1_stack[1024];  
  6. struct rt_thread thread1;  
  7. static void rt_thread_entry1(void *parameter)  
  8. {  
  9.     rt_uint32_t i;  
  10.     share_var = 0;  
  11.     rt_kprintf("share_var = %d\n", share_var);  
  12.     rt_thread_delay(1000);  
  13.     for (i = 0; i < 10000; i++)  
  14.     {  
  15.         share_var++;   
  16.     }  
  17.     rt_kprintf("\t share_var = %d\n", share_var);  
  18.     rt_kprintf("\t share_var = %d\n", share_var);  
  19. }  
  20.   
  21. static char thread2_stack[1024];  
  22. struct rt_thread thread2;  
  23. static void rt_thread_entry2(void *parameter)  
  24. {  
  25.     //rt_thread_delay(1);   
  26.     share_var++;  
  27. }  
  28.   
  29. int rt_application_init()  
  30. {  
  31.     rt_err_t result;  
  32.       
  33.     result =  rt_thread_init(&thread1,  
  34.         "thread1",  
  35.         rt_thread_entry1, RT_NULL,  
  36.         &thread1_stack[0], sizeof(thread1_stack),  
  37.         5, 5);  
  38.     if (result == RT_EOK)  
  39.         rt_thread_startup(&thread1);  
  40.           
  41.     result = rt_thread_init(&thread2,  
  42.         "thread2",  
  43.         rt_thread_entry2, RT_NULL,  
  44.         &thread2_stack[0], sizeof(thread2_stack),  
  45.         5, 5);  
  46.     if (result == RT_EOK)  
  47.         rt_thread_startup(&thread2);  
  48.   
  49.     return 0;  
  50. }  
  51.   
  52. /*@}*/    
#include <rtthread.h>

static rt_uint32_t share_var;

static char thread1_stack[1024];
struct rt_thread thread1;
static void rt_thread_entry1(void *parameter)
{
    rt_uint32_t i;
    share_var = 0;
    rt_kprintf("share_var = %d\n", share_var);
    rt_thread_delay(1000);
    for (i = 0; i < 10000; i++)
    {
        share_var++; 
    }
    rt_kprintf("\t share_var = %d\n", share_var);
    rt_kprintf("\t share_var = %d\n", share_var);
}

static char thread2_stack[1024];
struct rt_thread thread2;
static void rt_thread_entry2(void *parameter)
{
    //rt_thread_delay(1);
    share_var++;
}

int rt_application_init()
{
    rt_err_t result;
    
    result =  rt_thread_init(&thread1,
        "thread1",
        rt_thread_entry1, RT_NULL,
        &thread1_stack[0], sizeof(thread1_stack),
        5, 5);
    if (result == RT_EOK)
        rt_thread_startup(&thread1);
        
    result = rt_thread_init(&thread2,
        "thread2",
        rt_thread_entry2, RT_NULL,
        &thread2_stack[0], sizeof(thread2_stack),
        5, 5);
    if (result == RT_EOK)
        rt_thread_startup(&thread2);

    return 0;
}

/*@}*/


输出结果：

 

 

[cpp] view plaincopyprint?
  1. share_var = 0  
  2. share_var = 100001  
share_var = 0
share_var = 100001
posted @ 2013-12-05 16:44  莫回头  阅读(214)  评论(0)    收藏  举报