RT-Thread-一点小总结RT-Thread问答社区

一点小总结

发布于 2013-07-15 01:40:26 浏览：5419 订阅该版

下面是一些我犯过的错误，总结了一下，希望能帮到一些对操作系统不太熟悉的新手朋友，
同时也请高手证实一下。

（1）、线程的删除后，要会在rt_thread_delay()放弃CPU主动权后执行idle线程时才会被彻底回收。
若不放弃，则idle线程会一直得不到cpu而无法彻底回收被删除的线程。
 [viewtopic.php?f=2&t=2909](http://www.rt-thread.org/phpBB3/viewtopic.php?f=2&t=2909)

（2）、若线程出现-2的错误，则很有可能是高优先级的线程一直占用CPU没有释放导致该线程不会被执行。
这是我多次观察的结果，求证。。。

以上两点说明，不要写一直占用CPU的线程，否则IDLE线程一直不会执行，因为IDLE线程的优先级很低。

（3）、软件定时器停止rt_timer_stop后再启动rt_timer_start时，会重新装入初值而重新启动。

（4）、再启动一个已经启动的软件定时器，则会无任何作用，不会对定时器作任何改变。

（5）、sem不具有优先级继承，可能发生优先级反转，可能出现死锁。下面是两个信号量的死锁例子：
```
rt_sem_t sem1,sem2;

static void task1_entry(void* para)
{
    rt_kprintf("task1 try to get sem1...
");
    rt_sem_take(sem1, RT_WAITING_FOREVER);
    rt_kprintf("task1 got sem1.
");

rt_thread_delay(RT_TICK_PER_SECOND);

rt_kprintf("task1 try to get sem2...
");
    rt_sem_take(sem2, RT_WAITING_FOREVER);
    rt_kprintf("task1 got sem2.
");
   
    rt_kprintf("task1 release sem1
");
    rt_sem_release(sem1);

rt_kprintf("task1 release sem2
");
    rt_sem_release(sem2);

}
static void task2_entry(void* para)
{
    rt_kprintf("task2 try to get sem2...
");
    rt_sem_take(sem2, RT_WAITING_FOREVER);
    rt_kprintf("task2 got sem2.
");

rt_thread_delay(RT_TICK_PER_SECOND);

rt_kprintf("task2 try to get sem1...
");
    rt_sem_take(sem2, RT_WAITING_FOREVER);
    rt_kprintf("task2 got sem1.
");
   
    rt_kprintf("task2 release sem2
");
    rt_sem_release(sem2);

rt_kprintf("task2 release sem1
");
    rt_sem_release(sem1);
}

static void test_thread_entry(void* parameter)
{
        rt_thread_t tid;

sem1 = rt_sem_create("sem1", 1, RT_IPC_FLAG_PRIO);
        if (sem1 == RT_NULL)
        {
            rt_kprintf("creat sem1 failed.
");
            return;
        }
        sem2 = rt_sem_create("sem2", 1, RT_IPC_FLAG_PRIO);
        if (sem2 == RT_NULL)
        {
            rt_kprintf("creat sem2 failed.
");
            return;
        }

tid = rt_thread_create("task1",task1_entry,(void *)1,512,20,5);
        if(tid != RT_NULL)
            rt_thread_startup(tid);
        else
            rt_kprintf("creat task1 failed.
");

tid = rt_thread_create("task2",task2_entry,(void *)2,512,20,5);
        if(tid != RT_NULL)
            rt_thread_startup(tid);
        else
            rt_kprintf("creat task2 failed.
");

}
```

测试结果如下：
```
task1 try to get sem1...
task1 got sem1.
task2 try to get sem2...
task2 got sem2.
task1 try to get sem2...
task2 try to get sem1...

finsh>>list_sem()
semaphore v   suspend thread
--------  --- --------------
sem2      000 1:task1
sem1      000 1:task2
sem1      000 0
shrx      000 0
e0        000 0
tx_wait   000 0
heap      001 0
        0, 0x00000000
```

（6）、信号量的rt_sem_take不能在中断里进行，因为这个函数可能挂起当前线程，而中断里不存在线程一说。
（7）、信号量的释放rt_sem_release可以在中断里进行。
（8）、邮箱、消息队列同（6）、（7）描述相似。
（9）、互斥量不仅仅是二值信号量，它还有所有者，它可以改变当前线程的优先级，当它成功rt_take_mutex时，
          它的线程优先级会继承，不会产生优先级翻转。
           [viewtopic.php?f=28&t=1974](http://www.rt-thread.org/phpBB3/viewtopic.php?f=28&t=1974) 
（10）、当互斥量成功rt_take_mutex时，若此线程接着再对这个互斥量rt_take_mutex，也会成功而不会被挂起，
          而信号量sem就不一定。
（11）、互斥量的take与release都不能在中断里进行，而信号量的release可以。
（12）、父线程创建子线程时，子线程的优先级不要比父线程的优先级高，在创建多个高优先子线程时，父线程会未完成
           我们期望的工作而被抢占，达不到预计目的。例如：下面的低优先级的线程1不会被高优先级的线程2抢占：
```
static void task1_entry(void* para)
{
    rt_uint32_t t1_count;
    for(t1_count = 0; t1_count < 5; t1_count ++)
    {
        rt_kprintf("task1 count: %d
", t1_count);
    }
}
static void task2_entry(void* para)
{
    rt_uint32_t t2_count = 0;
    for(t2_count = 0; t2_count < 5; t2_count ++)
    {
        rt_kprintf("task2 count: %d
", t2_count);
    }
}
static void test_thread_entry(void* parameter)
{
        rt_thread_t tid;
        tid = rt_thread_create("task1",task1_entry,(void *)1,512,10,5);
        if(tid != RT_NULL)
            rt_thread_startup(tid);
        else
            rt_kprintf("creat task1 failed.
");

tid = rt_thread_create("task2",task2_entry,(void *)2,512,9,5);
        if(tid != RT_NULL)
            rt_thread_startup(tid);
        else
            rt_kprintf("creat task2 failed.
");
}

```

结果如下：
```
task1 count: 0
task1 count: 1
task1 count: 2
task1 count: 3
task1 count: 4
task2 count: 0
task2 count: 1
task2 count: 2
task2 count: 3
task2 count: 4
```
这是为什么呢？这个时候很容易去怀疑RT-Thread有bug。其实问题出在test_thread_entry
这个父线程的优先级太低，task1创建完成后立即启动，task1比test_thread这个父线程优先级
高，于是立即抢占父线程，task2虽然优先级更高，但是它在task1运行结束之前都还没有被创建！！
所以才会出现这样的现象，让人错觉：task1的优先级至少不会比task2低。
将父线程的优先级改成9（与task2相同优先级）后，再看看结果：
```
task2 count: 0
task2 count: 1
task2 count: 2
task2 count: 3
task2 count: 4
task1 count: 0
task1 count: 1
task1 count: 2
task1 count: 3
task1 count: 4
```
一切正常！

后面继续学习，继续补充！（出现了问题要多多怀疑自己）