互斥量的使用

互斥量的使用

例说互斥量

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

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

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

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

互斥量工作机制

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

互斥量的使用

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

互斥量控制块

在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. 使用信号量可能导致线程优先级反转,而互斥量可通过优先级继承的方法解决优先级反转问题
上一篇:程序员的自我修养(六):保护线程间的共享数据 转载


下一篇:Windows下C++多线程编程(入门实例)