1、信号量

信号量是一种轻型的用于解决线程间同步问题的内核对象，线程可以获取或释放它，从而达到同步或互斥的目的。
每个信号量对象都有一个信号量值和一个线程等待队列，信号量的值对应了信号量对象的实例数目、资源数目，假如信号量值为 5，则表示共有 5 个信号量实例（资源）可以被使用，当信号量实例数目为零时，再申请该信号量的线程就会被挂起在该信号量的等待队列上，等待可用的信号量实例（资源）

1.1创建和删除信号量

  1. #define DBG_TAG "main"
  2. #define DBG_LVL DBG_LOG
  3. #include <rtdbg.h>
  5. rt_sem_t semout1 = NULL;
  7. int main(void)
  8. {
  9.     //名字小于八个字符
  10.     semout1 = rt_sem_create("sem1", 1, RT_IPC_FLAG_FIFO);
  11.     if(semout1 == NULL)
  12.     {
  13.         LOG_E("semout1 is error.......\n");
  14.         return -ENOMEM;
  15.     }
  16.     else {
  17.         LOG_E("semout1 is successful.......\n");
  18.     }  
  19.     //rt_sem_delete(semout1);
  20.     return 0;
  21. }

1.2初始化和脱离信号量

  1. #define DBG_TAG "main"
  2. #define DBG_LVL DBG_LOG
  3. #include <rtdbg.h>
  5. struct rt_semaphore sem2;
  7. int main(void)
  8. {
  9.     int ret2 = 0;
  10.     ret2 = rt_sem_init(&sem2, "sem2", 2, RT_IPC_FLAG_FIFO);//如果直接定义指针就只有一个指针的大小；
  11.     if(ret2 < 0)
  12.     {
  13.         LOG_E("sem2 is error.......\n");
  14.         return ret2;
  15.     }
  16.     else {
  17.         LOG_E("sem2 is successful.......\n");
  18.     }
  20.     //rt_sem_detach(&sem2);
  21.     return 0;
  22. }

1.3获取释放信号量

线程通过获取信号量来获得信号量资源实例，当信号量值大于零时，线程将获得信号量，并且相应的信号量值会减 1，如果信号量的值等于零，那么说明当前信号量资源实例不可用，申请该信号量的线程将根据time参数的情况选择直接返回、或挂起等待一段时间、或永久等待，直到其他线程或中断释放该信号量。如果在参数time指定的时间内依然得不到信号量，线程将超时返回，返回值是 - RT_ETIMEOUT。

  1. #include <rtthread.h>
  3. #define DBG_TAG "main"
  4. #define DBG_LVL DBG_LOG
  5. #include <rtdbg.h>
  7. rt_sem_t semout1 = NULL;
  8. struct rt_semaphore sem2;
  10. int flags = 0;
  12. rt_thread_t rtt_ntr1 = NULL;
  13. rt_thread_t rtt_ntr2 = NULL;
  14. void th_entry1(void *parameter)
  15. {
  16.     while(1)
  17.     {
  18.         rt_thread_mdelay(800);
  19.         rt_sem_take(semout1, RT_WAITING_FOREVER);
  20.         flags++;
  21.         if(flags == 100)
  22.         {
  23.             flags = 0;
  24.         }
  25.         rt_kprintf("th_entry1 is running and the flags = %d.......\n\r",flags);
  26.         rt_sem_release(&sem2);
  28.     }
  29. }
  31. void th_entry2(void *parameter)
  32. {
  33.     while(1)
  34.     {
  35.         rt_sem_take(&sem2, RT_WAITING_FOREVER);
  36.         flags--;
  37.         rt_kprintf("th_entry2 is running and the flags = %d.......\n\r",flags);
  38.         rt_sem_release(semout1);
  39.         rt_thread_mdelay(100);
  40.     }
  41. }
  43. int main(void)
  44. {
  45.     //名字小于八个字符
  46.     semout1 = rt_sem_create("sem1", 1, RT_IPC_FLAG_FIFO);
  47.     if(semout1 == NULL)
  48.     {
  49.         LOG_E("semout1 is error.......\n");
  50.         return -ENOMEM;
  51.     }
  52.     else {
  53.         LOG_E("semout1 is successful.......\n");
  54.     }
  56.     //rt_sem_delete(semout1);
  57.     int ret2 = 0;
  58.     ret2 = rt_sem_init(&sem2, "sem2", 0, RT_IPC_FLAG_FIFO);//如果直接定义指针就只有一个指针的大小；
  59.     if(ret2 < 0)
  60.     {
  61.         LOG_E("sem2 is error.......\n");
  62.         return ret2;
  63.     }
  64.     else {
  65.         LOG_E("sem2 is successful.......\n");
  66.     }
  67.     //rt_sem_detach(&sem2);
  69.     rtt_ntr1 = rt_thread_create("test",th_entry1,NULL,512,20,5);
  70.     if(rtt_ntr1 == RT_NULL)
  71.     {
  72.         LOG_E("rt_thread_create1 error .....\n");
  73.         return -RT_ENOMEM;
  74.     }
  75.     else {
  76.         LOG_E("rt_thread_create1 successful .....\n");
  77.         rt_thread_startup(rtt_ntr1);
  78.     }
  80.     rtt_ntr2 = rt_thread_create("test",th_entry2,NULL,512,20,5);
  81.     if(rtt_ntr2 == RT_NULL)
  82.     {
  83.         LOG_E("rt_thread_create2 error .....\n");
  84.         return -RT_ENOMEM;
  85.     }
  86.     else {
  87.         LOG_E("rt_thread_create2 successful .....\n");
  88.         rt_thread_startup(rtt_ntr2);
  89.     }
  90.     return 0;
  91. }

image.png

2、互斥量

互斥量体现的是排他性，也是解决多线程同时操作临界区临界资源导致的竟态的一种方法。（类似于特殊的信号量——二值信号量）
区别：信号量可由不同线程释放，互斥量只能由同一线程进行释放。

  1. rt_mutex_t mux1 = NULL;
  3.     mux1 = rt_mutex_create("mutex1", RT_IPC_FLAG_FIFO);
  4.     if(mux1 == NULL)
  5.     {
  6.         LOG_E("mutex1 is error.......\n");
  7.         return -ENOMEM;
  8.     }
  9.     else {
  10.         LOG_E("mutex1 is successful.......\n");
  11.     }
  12.     //rt_mutex_delete(mux1);

示例：

  1. #include <rtthread.h>
  3. #define DBG_TAG "main"
  4. #define DBG_LVL DBG_LOG
  5. #include <rtdbg.h>
  7. rt_mutex_t mutex1 ;
  8. struct rt_mutex mutex2;
  10. rt_thread_t th1 , th2;
  11. int flag1 = 0, flag2 = 0;
  13. void th1_entry(void *parameter)
  14. {
  15.     while(1){
  16.         rt_mutex_take(mutex1, RT_WAITING_FOREVER);
  17.         flag1++;
  18.         rt_thread_mdelay(1000);
  19.         flag2++;
  20.         rt_kprintf("th1_entry   flag1:%d,flag2:%d\n",flag1,flag2);
  21.         rt_mutex_release(mutex1);
  22.     }
  23. }
  25. void th2_entry(void *parameter)
  26. {
  27.     while(1){
  29.         rt_mutex_take(mutex1, RT_WAITING_FOREVER);
  30.         flag1++;
  31.         flag2++;
  32.         rt_mutex_release(mutex1);
  33.         rt_kprintf("th2_entry  flag1:%d,flag2:%d\n",flag1,flag2);
  34.         rt_thread_mdelay(1000);
  35.     }
  36. }
  38. int main(void)
  39. {
  40.     //动态创建互斥锁
  41.     mutex1 = rt_mutex_create("mutex1", RT_IPC_FLAG_FIFO);
  42.     if(mutex1 == RT_NULL){
  43.         LOG_E("mutex1 rt_mutex_create failed...\n");
  44.         return -ENOMEM;
  45.     }
  46.     LOG_D("rt_mutex_create successed...\n");
  48.     th1 = rt_thread_create("th1", th1_entry,RT_NULL,512, 20, 5);
  49.     if(th1 == RT_NULL){
  50.         LOG_E("th1 rt_thread_create failed...\n");
  51.         return -ENOMEM;
  52.     }
  54.     th2 = rt_thread_create("th2", th2_entry,RT_NULL,512, 20, 5);
  55.     if(th1 == RT_NULL){
  56.        LOG_E("th2 rt_thread_create failed...\n");
  57.        return -ENOMEM;
  58.     }
  60.     rt_thread_startup(th1);
  61.     rt_thread_startup(th2);
  63.     return 0;
  64. }

3、事件集

事件集也是线程间同步的机制之一，一个事件集可以包含多个事件，利用事件集可以完成一对多，多对多的线程间同步。
一个线程和多个事件的关系可设置为：
其中任意一个事件唤醒 线程，或几个事件都到达后唤醒线程，多个事件集合可以用一个32bit无符号整型变量来表示，变量的每一位代表一个事件，线程通过”逻辑与”或”逻辑或”将一个或多个事件关联起来，形成事件组合。
RT-Thread 定义的事件集有以下特点：
☐ 事件只与线程相关，事件间相互独立
☐ 事件仅用于同步，不提供数据传输功能
☐ 事件无排队性，即多次向线程发送同一事件(如果线程还未来得及读走)，其效果等同于只发送一次
对一个事件集的操作包含：创建/初始化事件集、发送事件、接收事件、删除/脱离事件集。
image.png

  2. #include <rtthread.h>
  4. #define DBG_TAG "main"
  5. #define DBG_LVL DBG_LOG
  6. #include <rtdbg.h>
  8. rt_event_t event1;
  10. rt_thread_t th1 , th2 ,th3; //动态创建
  12. #define EVENT_FLAGS_1 (0x1 << 1)
  13. #define EVENT_FLAGS_2 (0x1 << 2)
  14. #define EVENT_FLAGS_3 (0x1 << 3)
  17. void th1_entry(void *parameter)
  18. {
  19.     rt_thread_mdelay(1000);
  20.     while(1){
  21.         rt_event_recv(event1, EVENT_FLAGS_1,RT_EVENT_FLAG_AND|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, NULL);
  22.         rt_kprintf("th1_entry...\n");
  23.         rt_thread_mdelay(1000);
  24.         rt_event_send(event1, EVENT_FLAGS_2);
  25.     }
  26. }
  28. void th2_entry(void *parameter)
  29. {
  30.     rt_thread_mdelay(500);
  31.     while(1){
  32.         rt_event_recv(event1, EVENT_FLAGS_2,RT_EVENT_FLAG_AND|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, NULL);
  33.         rt_kprintf("th2_entry...\n");
  34.         rt_thread_mdelay(1000);
  35.         rt_event_send(event1, EVENT_FLAGS_3);
  36.     }
  37. }
  39. void th3_entry(void *parameter)
  40. {
  41.     int ret = 0;
  42.     while(1){
  43.         ret = rt_event_recv(event1, EVENT_FLAGS_3,RT_EVENT_FLAG_AND|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, NULL);
  44.         rt_kprintf("th3_entry[%d]...\n",ret);
  45.         rt_thread_mdelay(1000);
  46.         rt_event_send(event1, EVENT_FLAGS_1);
  47.     }
  48. }
  50. int main(void)
  51. {
  52.     event1 = rt_event_create("set1", RT_IPC_FLAG_FIFO);
  53.     if(event1 == RT_NULL){
  54.         LOG_E("rt_event_create failed...\n");
  55.         return -ENOMEM;
  56.     }
  58.     LOG_D("rt_event_create successed...\n");
  60.     th1 = rt_thread_create("th1", th1_entry, NULL, 1024, 20, 5);
  61.     if(th1 == RT_NULL){
  62.         LOG_E("rt_thread_create failed...\n");
  63.         return -ENOMEM;
  64.     }
  66.     th2 = rt_thread_create("th2", th2_entry, NULL, 1024, 20, 5);
  67.     if(th2 == RT_NULL){
  68.         LOG_E("rt_thread_create failed...\n");
  69.         return -ENOMEM;
  70.     }
  72.     th3 = rt_thread_create("th3", th3_entry, NULL, 1024, 20, 5);
  73.     if(th3 == RT_NULL){
  74.             LOG_E("rt_thread_create failed...\n");
  75.             return -ENOMEM;
  76.     }
  78.     rt_thread_startup(th1);
  79.     rt_thread_startup(th2);
  80.     rt_thread_startup(th3);
  82.     rt_thread_mdelay(5000);
  83.     rt_event_send(event1, EVENT_FLAGS_1);
  85.     return 0;
  86. }