tm32 入门RT-Thread内核线程间的通讯—互斥量

1万 · 2021-1-12 10:40

互斥量用户线程间互斥访问的IPC对象，它是一种特殊的二值信号量。当某一个线程访问系统中的共享资源时，通过引入互斥量机制，可以保证其他线程无法取得对此共享资源的访问权。

1万 · 2021-1-12 10:41

互斥量只有两种状态：LOCKED和UNLOCKED，分别代表加锁和开锁的两种情况。当线程持有它时，互斥量处于闭锁状态，由这个线程获得它的所有权。相反，当这个线程释放它时，将互斥量进行开锁操作，失去对它的所有权。当一个线程持有互斥量时，其它线程不能对它开锁或者持有它，只有这个持有互斥量的线程才能释放它进行开锁操作，其它线程才能被持有。

1万 · 2021-1-12 10:41

在RT-Thread中，互斥量控制块是操作系统用于管理互斥量的一个数据结构。

复制

struct rt_mutex

{

    struct rt_ipc_object parent;               /**< inherit from ipc_object */

    rt_uint16_t   value;                    /**< value of mutex */

    rt_uint8_t   original_priority;             /**< priority of last thread hold the mutex */

    rt_uint8_t   hold;                      /**< numbers of thread hold the mutex */

    struct rt_thread  *owner;                /**< current owner of mutex */

};

typedef struct rt_mutex *rt_mutex_t;

1万 · 2021-1-12 10:41

定义静态互斥量： rt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag);
定义动态互斥量：rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag);

1万 · 2021-1-12 10:41

互斥量的操作函数：
创建静态互斥量
rt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag);
rt_err_t rt_mutex_detach(rt_mutex_t mutex);
创建和删除动态互斥量
rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag);
rt_err_t rt_mutex_delete(rt_mutex_t mutex);
获取互斥量
rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t time);
释放互斥量
rt_err_t rt_mutex_release(rt_mutex_t mutex);

1万 · 2021-1-12 10:42

基于STM32互斥量具体实例：

复制

// 定义共享资源变量

rt_uint16_t  mutex_num1 = 0;

rt_uint16_t  mutex_num2 = 0;

// 定义互斥量控制块

static  rt_mutex_t  mutex_num = RT_NULL;

//创建互斥量 

mutex_num = rt_mutex_create("mutex_test",RT_IPC_FLAG_FIFO);

if(mutex_num != RT_NULL)

{

        rt_kprintf("mutex create sucessful\n");

}

else

{

 rt_kprintf("mutex create fial\n");

                 return -1;

}

//创建线程

  led1_thread = rt_thread_create("led1",task1,RT_NULL,1024,2,10);

        if(led1_thread != RT_NULL)

                  rt_thread_startup(led1_thread);

  else

                 return -1;

        

        led2_thread = rt_thread_create("led2",task2,RT_NULL,1024,3,5);

        if(led2_thread != RT_NULL)

                  rt_thread_startup(led2_thread);

  else        

           return -1;



// 入口函数

oid task1(void *parameter)

{

    while(1)

                {

     

                         rt_mutex_take(mutex_num,RT_WAITING_FOREVER);

                   mutex_num1 ++;

                         rt_thread_mdelay(100);        

                         mutex_num2 ++;

                         rt_mutex_release(mutex_num);

                }         

}





void task2(void *parameter)

{

    while(1)

                {

                        

                        rt_mutex_take(mutex_num,RT_WAITING_FOREVER);

                        if(mutex_num1 != mutex_num2)

                        {

                          rt_kprintf("mutex is Fial\n");

                        }

                        else

                        {

                           rt_kprintf("mutex is sucessful\n");

                        }

                        rt_mutex_release(mutex_num);

            rt_thread_mdelay(1000);        



                }        

}