嵌入式实时操作系统的设计与开发（互斥量学习）

一个无论多么小的系统，都会有大系统的缩影，就像俗话说“麻雀虽小五脏俱全”。

嵌入式实时操作系统中除了基本调度机制（创建线程、调度线程、挂起线程等），事件处理机制（中断管理、时钟管理）、内存管理机制外，也有一般操作所具有的线程交互机制，如 互斥机制、同步机制、通信机制等。

并发线程可共享系统中的各类资源，如全局变量、表格、队列、打印机等，这些资源被称为临界资源，当诸线程在访问这些临界资源时，必须互斥访问。

互斥，顾名思义，大家都要相互排斥，因此在同一个时刻，只能有一个任务拥有互斥量。

大家把每个线程中访问临界资源的那段代码称为临界区，把线程刚开始执行临界区代码和退出临界区代码的那一刻称为临界点。

临界区的代码需要互斥访问，即不允许多个线程，中断同时执行临界区域代码

HAL_INTR ENABLE:
	CPSIE i
	mov pc,lr

HAL_INTR_DISABLE:
	CPSID i
	mov pc,lr

线程和中断处理程序互斥：当线程在临界点关了中断，线程在执行临界区代码时，中断肯定不会发生，所以不会出现中断和线程同时访问临界区代码的情况。

互斥机制

除了HAL_ENTER_CRITICAL、HAL_EXIT_CRITICAL临界点机制可实现互斥外，还可以用互斥量机制实现互斥。

临界点机制是整个临界区域都关中断，而互斥量只是申请互斥量和释放互斥量时关中断，同时互斥量机制可能会引起线程挂起，导致线程切换

使用互斥量机制时临界区代码往往都比较长，对于线程之间互斥的代码区域，如果这段区域很小，小到执行时间少于线程切换的时间，优先使用临界点。

互斥量

使用互斥量（Mutex）可以有效管理系统中的独占资源，进而利用这一特性来实现对临界资源的管理，以便一个核上的多个任务，多个核上的多个任务在访问临界资源不会互相干扰，产生异常结果。
aCoral互斥量的实现依赖于事件控制块。

typedef enum{
	ACORAL_EVENT_SEM, //信号量
	ACORAL_EVENT_MUTEX //互斥量
}acoralEventEnum;

typedef struct{
	acoral_res_t res; //event也是一种资源
	unsigned char type;
	int count;//共用型变量，当type值不同时，count代表的意思也不同，当为互斥量时，16~24位代表这个互斥量的优先级天花板，这个值在互斥量被创建的时候就确定了并且不会改变，低16位中的高8位表示这个互斥量被占用时，因为尝试申请互斥量而被阻塞的线程中最高的优先级，低8位在互斥量没有被上锁时，为全1，表示互斥量可用；在被上锁，也就是被占用时，会赋值为占用它的线程的原始优先级。之所以说是原始优先级，是因为占用线程在使用互斥量的过程中可能被提升优先级，那么在释放互斥量之后就要恢复之前的优先级，从count的低八位取指。
	acoral_list_t wait_queue; //等待使用这个event的线程队列
	char *name; //名字
	void *data; //当event是mutex或semaphore时，指向占用线程，当event是消息队列时，存放传递的消息
}acoral_evt_t;

创建互斥量
创建互斥量的时候，需要指定的第一个参数为：互斥量的优先级，这个优先级为使用该互斥量的所有线程中最高的优先级，指定该参数是为了避免优先级反转，支持优先级继承；而第二个参数是该接口的返回信息，用来通知信号量创建者在创建过程的状态。
当创建成功时，返回指向该互斥量的指针

acoral_evt_t *acoral_mutex_create(unsigned char prio, unsigned int *err)
{
	acoral_evt_t *evt;
	evt = acoral_alloc_evt();//从资源内存池中分配一个事件块，分配的方式和线程控制块类似
	if(NULL == evt)
	{
		*err = MUTEX_ERR_NULL;
		return NULL;
	}
	evt->count = (prio << 16) | MUTEX_AVAI | MUTEX_U_MASK;
	evt->type = ACORAL_EVENT_MUTEX;
	evt->data = NULL;
	acoral_evt_init(evt);//初始化互斥量，创建互斥量的最后一步是对其进行初始化，
	return evt;
}

acoral_evt_t *acoral_alloc_evt()
{
	return (acoral_evt_t *)acoral_get_res(&acoral_evt_pool_ctrl);
}

void acoral_evt_init(acoral_evt_t *evt)
{
	acoral_init_list(&evt->wait_queue);
}

优先级反转

T1的优先级大于T2大于T3，T1与T3会访问共享资源S，T2不会。

1. T3在时刻0到达，并立即得以运行，随后，在t0时刻开始进入临界区访问共享资源S。
2. 在时刻t1，T1到达系统，T1抢占T3获得运行权，t2时刻，T1欲访问共享资源S，而此时S被T3占用，T1被切换到等待队列，CPU的执行权重新交给T3，T3继续访问S。
3. 在时刻t3，T2到达系统，T2抢占T3获得运行权，直到时刻t4，T2执行结束，CPU执行权交给T3。
4. 时刻t5，T3结束共享资源的访问，释放共享资源S，这样，T1获得CPU使用权，直到t6。

虽然T2优先级小于T1，但T2延迟了T1的运行，T2先于T1执行完，该现象在RTOS中被称为优先级反转。

在多个任务需要访问共享资源的情况下可能会出现高优先级任务被低优先级任务阻塞，并等待低优先级任务运行，在此过程中，高优先级任务需要等待低优先级任务释放共享资源，而低优先级任务又在等待不访问共享资源的中等优先级任务的现象，称为优先级反转。

优先级反转造成了调度的不确定性。

优先级继承指当一个任务阻塞了一个或多个高优先级任务时，该任务将不使用原来的优先级，而暂时使用被阻塞任务中的最高优先级作为执行临界区的优先级，当该任务退出临界区时，再恢复到其最初优先级。

基本步骤如下：

1. 如果任务T为具有最高优先级的就绪任务，则T将获得运行权。在任务T进入临界区前，首先需要通过RTOS提供的API请求获得该临界区的互斥量S（acoral_mutex_pend()）
2. 如果互斥量S已经被上锁，则任务T的请求被拒绝。在该情况下，任务T被拥有互斥量S的任务所阻塞。
3. 如果互斥量S未被上锁，则任务获得互斥量S而进入临界区。当任务T退出临界区时，使用临界区过程中所上锁的信号被解锁（acoral_mutex_post()），此时如果有其它任务因为请求临界区而被阻塞，则其中具有最高优先级的任务将被激活，处于就绪状态。
4. 任务T将保持被分配的原有优先级不变，除非任务T进入了临界区并阻塞了更高优先级的任务。则T将继承被任务T阻塞的所有任务的最高优先级，直到任务T退出临界区。当T退出临界区时，将恢复到进入临界区前的原有优先级。
5. 优先级继承具有传递性。

是否存在优先级反转的条件：

1. 已占有互斥量的线程优先级不是创建互斥量时设置的最高优先级。
2. 且已占有互斥量的线程优先级小于当前线程的优先级。
3. 且已占有互斥量的线程和当前线程并发使用一个CPU时。

acoralMutexRetVal acoral_mutex_post(acoral_evt_t *evt)
{
	unsigned char ownerPrio;
	unsigned char highPrio;
	acoral_thread_t *thread;
	acoral_thread_t *cur;
	acoral_enter_critical();
	if (NULL == evt)
	{
		acoral_print("mutex NULL\n");
		acoral_exit_critical();
		return MUTEX_ERR_NULL; /*error*/
	}

	highPrio = (unsigned char)(evt->count >> 8);
	ownerPrio = (unsigned char)(evt->count & MUTEX_L_MASK);
	cur = acoral_cur_thread;
	if(highPrio != 0 && cur->prio != highPrio && cur->prio != ownerPrio)
	{
		acoral_print("mutex prio err\n");
		acoral_exit_critical();
		return MUTEX_ERR_UNDEF;
	}
	cur->evt = NULL;
	if(cur->prio != ownerPrio)
	{
		acoral_change_prio_self(ownerPrio);
	}
	thread = acoral_evt_high_thread(evt);
	if(thread == NULL)
	{
		evt->count |= MUTEX_AVAI;
		evt->data = NULL;
		acoral_exit_critical();
		return MUTEX_SUCCED;
	}
	timeout_queue_del(thread);
	acoral_evt_queue_del(thread);
	evt->count &= MUTEX_U_MASK;
	evt->count |= thread->prio;
	evt->data = thread;
	acoral_rdy_thread(thread);
	acoral_exit_critical();
	acoral_sched();
	return MUTEX_SUCCED;
}

删除互斥量：当互斥量不再使用时，需要对其进行删除，以回收内存空间，删除互斥量的接口acoralMutexRetVal acoral_mutex_del(acoral_evt_t *evt, unsigned int opt)
需要传递对应的指向互斥量结构的指针，同时需要指定删除时的属性，当opt的值为ACORAL_MUTEX_FORCEDEL时，不管有无线程在等待，都会删除互斥量，归还互斥量块到事件块缓冲池中。
当opt的值为ACORAL_NORMALDEL时，如果有线程在等待，则不会进行删除，通过返回值通知删除状态。

acoralMutexRetVal acoral_mutex_del(acoral_evt_t *evt, unsigned int opt)
{
	if(NULL == evt)
	{
		return MUTEX_ERR_NULL;
	}
	if(ACORAL_EVENT_MUTEX != evt->type)
	{
		return MUTEX_ERR_TYPE;
	}
	acoral_enter_critical();
	if(acoral_evt_queue_empty(evt))
	{
		acoral_exit_critical();
		return MUTEX_SUCCED;
	}
	else
	{
		/*有等待任务*/
		acoral_exit_critical();
		return MUTEX_ERR_TASK_EXIST;
	}
}

对于多核嵌入式平台，aCoral提供了另一种互斥机制：自旋锁。
原来的临界点机制仅仅通过关中断，是没法实现多核环境下互斥访问的，因为临界点机制只能保证同一个核上的线程之间线程和中断的互斥。
而在多核情况下，线程是可同时在不同核上运行的，这就需要一种核间互斥的机制，也就是自旋锁。