互斥量的使用
例说互斥量
我们来看一个生活中的例子：
现在大多银行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不再相等。
信号量和互斥量的比较
- 信号量可以由任何线程(以及中断)释放，它用于同步的时候就像交通灯，线程只有在获得许可的时候才可以运行，强调的是运行步骤；互斥量只能由持有它的线程释放，即只有“锁上”它的那个线程才有“钥匙”打开它，它用于互斥的时候就像一把钥匙， 只有获得钥匙的线程才可以运行，强调的是许可和权限。
- 使用信号量可能导致线程优先级反转，而互斥量可通过优先级继承的方法解决优先级反转问题