互斥量的使用

例说互斥量

我们来看一个生活中的例子：

现在大多银行ATM机都有一个特制的铁门。需要使用ATM的用户都需要在门前排队，进入铁门使用ATM机的用户进入后会在里面将铁门锁住，以保障自身安全，这个时候，在门外排队的用户无法使用ATM机；

当之前锁住ATM铁门的用户办理完业务，打开门以后，其他在外排队的用户才可以进入铁门使用ATM，这位进入铁门的用户也会和前一个用户一样，将门锁住，保障自身的安全。

例子中ATM机就相当于系统中的共享资源，需要使用ATM的用户相当于系统中的线程，而铁门，就起到了互斥量的作用。

互斥量工作机制

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

互斥量只有两种状态: LOCKED和UNLOCKED， 分别代表加锁和开锁的两种情况。当有线程持有它时，互斥量处于闭锁状态，由这个线程获得它的所有权。相反，当这个线程释放它时，将对互斥量进行开锁，失去对它的所有权。当一个线程持有互斥量时，其他线程将不能够对它进行开锁或持有它。持有该互斥量的线程也能够再次获得这个"锁"(递归持有)而不被挂起。

互斥量控制块

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

/* 在rtdef.h中对结构体的定义 */

#ifdef RT_USING_MUTEX
/**
 * Mutual exclusion (mutex) structure
 */
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;
#endif

struct rt_mutex static_mutex;		//定义静态互斥量
rt_mutex_t dynamic_mutex;			//定义动态互斥量

互斥量的操作

初始化与脱离

//用于静态信号量
rt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag)
/*
*rt_uint8_t flag的选择：
*	RT_IPC_FLAG_FIFO:先进先出顺序
*	RT_IPC_FLAG_PRIO:优先级顺序
*/
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_int32_t time:
*	0:立即返回；-1（即RT_WAITING_FOREVER）：永远在该信号等待；>0：等待相应滴答时钟
*补充:该函数会导致线程被挂起，由于中断是快进快出，故只能在线程中使用，在中断中会导致ISR永远无法返回
*	当一个线程获取了互斥量，其它线程仍能获取，不会被挂起，此时hold会加一
*/

释放互斥量

rt_err_t rt_mutex_release(rt_mutex_t mutex)
/* 只有take了才能释放,且同take一样，只属于线程，不能在中断中使用 */

小例

代码

/*
 * 程序清单：互斥锁例程
 *
 * 互斥锁是一种保护共享资源的方法。当一个线程拥有互斥锁的时候，
 * 可以保护共享资源不被其他线程破坏。线程1对2个number分别进行加1操作
 * 线程2也会对2个number分别进行加1操作。使用互斥量保证2个number值保持一致
 */
#include <rtthread.h>

#define THREAD_PRIORITY         8
#define THREAD_TIMESLICE        5

/* 指向动态互斥量的指针 */
static rt_mutex_t dynamic_mutex = RT_NULL;
static rt_uint8_t number1,number2 = 0;

ALIGN(RT_ALIGN_SIZE)
static char thread1_stack[1024];
static struct rt_thread thread1;
static void rt_thread_entry1(void *parameter)
{
      while(1)
      {
          /* 线程1获取到互斥量后，先后对number1、number2进行加1操作，然后释放互斥量 */
          rt_mutex_take(dynamic_mutex, RT_WAITING_FOREVER);          
          number1++;
          rt_thread_mdelay(10);
          number2++;          
          rt_mutex_release(dynamic_mutex);
       }	    
}

ALIGN(RT_ALIGN_SIZE)
static char thread2_stack[1024];
static struct rt_thread thread2;
static void rt_thread_entry2(void *parameter)
{     
      while(1)
      {
          /* 线程2获取到互斥量后，检查number1、number2的值是否相同，相同则表示mutex起到了锁的作用 */
          rt_mutex_take(dynamic_mutex, RT_WAITING_FOREVER);
          if(number1 != number2)
          {
            rt_kprintf("not protect.number1 = %d, mumber2 = %d \n",number1 ,number2);
          }
          else
          {
            rt_kprintf("mutex protect ,number1 = mumber2 is %d\n",number1);            
          }
          
           number1++;
           number2++;
           rt_mutex_release(dynamic_mutex);
          
          if(number1 >=50)
              return;      
      }	  
}

/* 互斥量示例的初始化 */
int mutex_sample(void)
{
    /* 创建一个动态互斥量 */
    dynamic_mutex = rt_mutex_create("dmutex", RT_IPC_FLAG_FIFO);
    if (dynamic_mutex == RT_NULL)
    {
        rt_kprintf("create dynamic mutex failed.\n");
        return -1;
    }

    rt_thread_init(&thread1,
                   "thread1",
                   rt_thread_entry1,
                   RT_NULL,
                   &thread1_stack[0],
                   sizeof(thread1_stack), 
                   THREAD_PRIORITY, THREAD_TIMESLICE);
    rt_thread_startup(&thread1);
    
    rt_thread_init(&thread2,
                   "thread2",
                   rt_thread_entry2,
                   RT_NULL,
                   &thread2_stack[0],
                   sizeof(thread2_stack), 
                   THREAD_PRIORITY-1, THREAD_TIMESLICE);
    rt_thread_startup(&thread2);
    return 0;
}

/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(mutex_sample, mutex sample);

结果

分析

首先定义了一个互斥量，由于线程1快于线程2开始，则线程1的入库函数首先执行，并获取到互斥量使其为UNLOCKED，此时进行线程1的操作，使number1先加一，再挂起10ms，由于此时互斥量还没有对线程2开锁（未释放），故线程1挂起时线程2仍然挂起，直到线程1执行完number2加一并释放互斥量时，线程2才被唤醒；而同样，当线程2获取到互斥量后，线程2首先打印输出，并使number1和number2分别加一，再释放互斥量使线程1又被唤醒；如此反复，number1和number2将会一直相等，若不采用互斥量，在线程1挂起的10ms内，线程2将会执行其相应操作，使得number1和number2不再相等。

信号量和互斥量的比较

1. 信号量可以由任何线程(以及中断)释放，它用于同步的时候就像交通灯，线程只有在获得许可的时候才可以运行，强调的是运行步骤；互斥量只能由持有它的线程释放，即只有“锁上”它的那个线程才有“钥匙”打开它，它用于互斥的时候就像一把钥匙， 只有获得钥匙的线程才可以运行，强调的是许可和权限。
2. 使用信号量可能导致线程优先级反转，而互斥量可通过优先级继承的方法解决优先级反转问题

标签：rt,RT,使用,互斥,线程,number1,mutex
来源： https://blog.csdn.net/hankyt/article/details/119156137