AliOS-Things+STM32 (三) 同步机制（mutex）

最新推荐文章于 2024-06-28 00:24:55 发布
最新推荐文章于 2024-06-28 00:24:55 发布
阅读量1.4k 收藏 3
点赞数
分类专栏： Alios-Things分析 文章标签： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhang_heaven/article/details/104238248
版权

一个操作系统中，进程的同步机制很多，这篇先介绍比较使用比较广泛的mutex，因为有些后续的内容也会用到mutex，所以先介绍。
Alios-Things中的mutex结构体如下：

typedef struct mutex_s {
    blk_obj_t       blk_obj;	/*blk对象，记录task调用mutex如果被阻塞住时的一些信息记录*/
    ktask_t        *mutex_task; /* mutex owner task */
    struct mutex_s *mutex_list; /* task mutex list */
    mutex_nested_t  owner_nested; /*循环嵌套时的标记*/

#if (RHINO_CONFIG_KOBJ_LIST > 0)
    klist_t         mutex_item;	/*mutex对象管理链表的挂接点*/
#endif
    uint8_t         mm_alloc_flag;	/*mutex内存申请类型*/
} kmutex_t;

typedef struct blk_obj {
    klist_t       blk_list;		/*记录被该mutex阻塞的task连接的链表*/
    const name_t *name;			
    blk_policy_t  blk_policy;	/*阻塞的规则，BLK_POLICY_PRI：按优先级，BLK_POLICY_FIFO：按照先进先出*/
    kobj_type_t   obj_type;		/*kobj类型， mutex为RHINO_MUTEX_OBJ_TYPE*/
#if (RHINO_CONFIG_USER_SPACE > 0)
    klist_t       obj_list;
#endif
#if (RHINO_CONFIG_TASK_DEL > 0)
    uint8_t       cancel;		/*设置1用来判断task是否已经被取消*/
#endif
} blk_obj_t;

与mutex相关的，提供给用户使用的函数接口如下：

/**
 * This function will create a mutex
 * @param[in] mutex  pointer to the mutex(the space is provided by user)
 * @param[in] name   name of the mutex
 * @return the operation status, RHINO_SUCCESS is OK, others is error
 */
kstat_t krhino_mutex_create(kmutex_t *mutex, const name_t *name);

/**
 * This function will delete a mutex
 * @param[in] mutex pointer to the mutex
 * @return the operation status, RHINO_SUCCESS is OK, others is error
 */
kstat_t krhino_mutex_del(kmutex_t *mutex);

#if (RHINO_CONFIG_KOBJ_DYN_ALLOC > 0)
/**
 * This function will create a dyn mutex
 * @param[in]  mutex  pointer to the mutex(the space is provided by user)
 * @param[in]  name   name of the mutex
 * @return  the operation status, RHINO_SUCCESS is OK, others is error
 */
kstat_t krhino_mutex_dyn_create(kmutex_t **mutex, const name_t *name);

/**
 * This function will delete a dyn mutex
 * @param[in] mutex  pointer to the mutex
 * @return the operation status, RHINO_SUCCESS is OK, others is error
 */
kstat_t krhino_mutex_dyn_del(kmutex_t *mutex);
#endif

/**
 * This function will lock mutex
 * @param[in]  mutex  pointer to the mutex
 * @param[in]  ticks  ticks to be wait for before lock
 * @return  the operation status, RHINO_SUCCESS is OK, others is error
 */
kstat_t krhino_mutex_lock(kmutex_t *mutex, tick_t ticks);

/**
 * This function will unlock a mutex
 * @param[in]  mutex  pointer to the mutex
 * @return  the operation status, RHINO_SUCCESS is OK, others is error
 */
kstat_t krhino_mutex_unlock(kmutex_t *mutex);

这其中krhino_mutex_dyn_create/krhino_mutex_dyn_del和krhino_mutex_create/krhino_mutex_del区别在于mutex的内存分配是动态分配，还是由用户自己提供分配好，我觉得一般使用肯定选前者动态分配来得方便。
所以我们需要分析的就如下几个函数：

  • kstat_t krhino_mutex_dyn_create(kmutex_t **mutex, const name_t *name);
  • kstat_t krhino_mutex_dyn_del(kmutex_t *mutex);
  • kstat_t krhino_mutex_lock(kmutex_t *mutex, tick_t ticks);
  • kstat_t krhino_mutex_unlock(kmutex_t *mutex);

先看kstat_t krhino_mutex_dyn_create(kmutex_t **mutex, const name_t *name);

kstat_t krhino_mutex_dyn_create(kmutex_t **mutex, const name_t *name)
{
    kstat_t   stat;
    kmutex_t *mutex_obj;

    if (mutex == NULL) {
        return RHINO_NULL_PTR;
    }

    NULL_PARA_CHK(mutex);
	/*动态申请kmutex_t结构体*/
    mutex_obj = krhino_mm_alloc(sizeof(kmutex_t));
    if (mutex_obj == NULL) {
        return RHINO_NO_MEM;
    }
	/*动态申请mutex结构体初始化*/
    stat = mutex_create(mutex_obj, name, K_OBJ_DYN_ALLOC);
    if (stat != RHINO_SUCCESS) {
        krhino_mm_free(mutex_obj);
        return stat;
    }

    *mutex = mutex_obj;

    return stat;
}

kstat_t mutex_create(kmutex_t *mutex, const name_t *name, uint8_t mm_alloc_flag)
{
#if (RHINO_CONFIG_KOBJ_LIST > 0)
    CPSR_ALLOC();
#endif

    NULL_PARA_CHK(mutex);
    NULL_PARA_CHK(name);

    memset(mutex, 0, sizeof(kmutex_t));

    /* init the list */
    klist_init(&mutex->blk_obj.blk_list);
    mutex->blk_obj.blk_policy = BLK_POLICY_PRI;
    mutex->blk_obj.name       = name;
    mutex->mutex_task         = NULL;
    mutex->mutex_list         = NULL;
    mutex->mm_alloc_flag      = mm_alloc_flag;
#if (RHINO_CONFIG_TASK_DEL > 0)
    mutex->blk_obj.cancel     = 0u;
#endif

#if (RHINO_CONFIG_KOBJ_LIST > 0)
    RHINO_CRITICAL_ENTER();
    klist_insert(&(g_kobj_list.mutex_head), &mutex->mutex_item);
    RHINO_CRITICAL_EXIT();
#endif

    mutex->blk_obj.obj_type = RHINO_MUTEX_OBJ_TYPE;

    TRACE_MUTEX_CREATE(krhino_cur_task_get(), mutex, name);

    return RHINO_SUCCESS;
}

mutex_create就是mutex的一些基本信息的初始化，基本都能一眼看懂。
接下来我们重点看kstat_t krhino_mutex_lock(kmutex_t *mutex, tick_t ticks);

kstat_t krhino_mutex_lock(kmutex_t *mutex, tick_t ticks)
{
    CPSR_ALLOC();

    kstat_t  ret;
    ktask_t *mutex_task;
    uint8_t  cur_cpu_num;

    NULL_PARA_CHK(mutex);

	//调度器未初始化的话，直接退出
    if (g_sys_stat == RHINO_STOPPED) {
        return RHINO_SUCCESS;
    }
	
	/*关中断*/
    RHINO_CRITICAL_ENTER();
	
	//获得当前cpu号
    cur_cpu_num = cpu_cur_get();
    TASK_CANCEL_CHK(mutex);

	/*判断是否是在中断中调用lock，如果是在中断中立刻返回。*/
    INTRPT_NESTED_LEVEL_CHK();
	/*判断mutex对象的类型是否真的是mutex类型*/
    if (mutex->blk_obj.obj_type != RHINO_MUTEX_OBJ_TYPE) {
        RHINO_CRITICAL_EXIT();
        return RHINO_KOBJ_TYPE_ERR;
    }

	/*如果调用lock的任务，和之前调用过lock的任务是一样的，那么就是嵌套调用，*/
    /* if the same task get the same mutex again, it causes mutex owner nested */
    if (g_active_task[cur_cpu_num] == mutex->mutex_task) {
    	/*mutex->owner_nested已经等于0xFFFFFFFF，嵌套过度*/
        if (mutex->owner_nested == (mutex_nested_t)-1) {
            /* fatal error here, system must be stoped here */
            k_err_proc(RHINO_MUTEX_NESTED_OVF);
            RHINO_CRITICAL_EXIT();
            return RHINO_MUTEX_NESTED_OVF;
        } else {
        	/*mutex嵌套计数++退出，表示同样的mutex，被同一个任务lock了多次，
        	后续需要同样多次unlock才能释放。*/
            mutex->owner_nested++;
        }

        RHINO_CRITICAL_EXIT();

        return RHINO_MUTEX_OWNER_NESTED;
    }

    mutex_task = mutex->mutex_task;
    /*mutex_task == NULL表明这个mutex没有被任何task获取过*/
    if (mutex_task == NULL) {
        /* get lock */
        mutex->mutex_task         = g_active_task[cur_cpu_num];
#if (RHINO_CONFIG_MUTEX_INHERIT > 0)
		/*mutex->mutex_list指向当前这个task的mutex_list*/
        mutex->mutex_list         = g_active_task[cur_cpu_num]->mutex_list;
        /*当前这个task的mutex_list指向该mutex，这样task所持有的所有mutex都在task的mutex_list的链表上*/
        g_active_task[cur_cpu_num]->mutex_list = mutex;
#endif
		//mutex嵌套计数设置为1
        mutex->owner_nested       = 1u;

        TRACE_MUTEX_GET(g_active_task[cur_cpu_num], mutex, ticks);

        RHINO_CRITICAL_EXIT();
		/*获取mutex完成退出*/
        return RHINO_SUCCESS;
    }

	/*程序如果走到这里，说明mutex被别的任务占用*/

	/*ticks设置0的话，不阻塞等待，直接退出*/
    /* can't get mutex, and return immediately if wait_option is RHINO_NO_WAIT */
    if (ticks == RHINO_NO_WAIT) {
        RHINO_CRITICAL_EXIT();
        return RHINO_NO_PEND_WAIT;
    }
	
	
    /* system is locked so task can not be blocked just return immediately */
    /*g_sched_lock[0] > 0表示该task设置过不能被调度，所以退出*/
    if (g_sched_lock[cur_cpu_num] > 0u) {
        RHINO_CRITICAL_EXIT();
        return RHINO_SCHED_DISABLE;
    }
#if (RHINO_CONFIG_MUTEX_INHERIT > 0)
    /* if current task is a higher prio task and block on the mutex
       prio inverse condition happened, prio inherit method is used here */
    /*如果当前将要被block的任务优先级高于持有mutex任务的优先级，
    为了防止mutex优先级反转，提高持有mutex任务的优先级，
    关于mutex优先级反转的内容，见本章最后*/
    if (g_active_task[cur_cpu_num]->prio < mutex_task->prio) {
        task_pri_change(mutex_task, g_active_task[cur_cpu_num]->prio);
        TRACE_TASK_PRI_INV(g_active_task[cur_cpu_num], mutex_task);
    }
#endif
	/*将当前任务从g_ready_queue里删去，放到mutex的blk_list*/
    /* any way block the current task */
    pend_to_blk_obj((blk_obj_t *)mutex, g_active_task[cur_cpu_num], ticks);

    TRACE_MUTEX_GET_BLK(g_active_task[cur_cpu_num], mutex, ticks);
	/*真正进行调度，这部分会在任务调度章节分析*/
    RHINO_CRITICAL_EXIT_SCHED();
	
	/*执行到这里，说明mutex被持有者释放掉了，本任务已经获取该mutex，
	或是获取mutex超时，超过ticks，或者其他原因等导致当前任务从阻塞变为运行状态*/
    RHINO_CPU_INTRPT_DISABLE();

	/*获取当前状态*/
    /* so the task is waked up, need know which reason cause wake up */
    ret = pend_state_end_proc(g_active_task[cpu_cur_get()], (blk_obj_t *)mutex);

    RHINO_CPU_INTRPT_ENABLE();

    return ret;
}

void pend_to_blk_obj(blk_obj_t *blk_obj, ktask_t *task, tick_t timeout)
{
    /* task need to remember which object is blocked on */
    task->blk_obj = blk_obj;
	
	/*如果超时不是RHINO_WAIT_FOREVER，那就把该任务挂到定时器上，并设定相应的timeout*/
    if (timeout != RHINO_WAIT_FOREVER) {
        tick_list_insert(task, timeout);
    }

	/*设置task状态为K_PEND*/
    task->task_state = K_PEND;

    /* remove from the ready list */
    ready_list_rm(&g_ready_queue, task);

	/*如果blk_policy 为BLK_POLICY_FIFO，则将任务插入到阻塞队列的队尾，如果是BLK_POLICY_PRI，
	则按照优先级插入任务，优先级较高的阻塞任务会在mutex释放时较先唤醒获得mutex*/
    if (blk_obj->blk_policy == BLK_POLICY_FIFO) {
        /* add to the end of blocked objet list */
        klist_insert(&blk_obj->blk_list, &task->task_list);
    } else {
        /* add to the prio sorted block list */
        pend_list_add(&blk_obj->blk_list, task);
    }
}

kstat_t pend_state_end_proc(ktask_t *task, blk_obj_t *blk_obj)
{
    kstat_t status;

    (void)blk_obj;

    switch (task->blk_state) {
    	/*task->blk_state=BLK_FINISH,表示task是由于mutex释放而唤醒，返回success*/
        case BLK_FINISH:
            status = RHINO_SUCCESS;
            break;
        /*task->blk_state=BLK_ABORT,表示task是由于本task被krhino_task_cancel后，
        为了跑完删除流程而唤醒，返回RHINO_BLK_TIMEOUT*/
        case BLK_ABORT:
            status = RHINO_BLK_ABORT;
            break;
        /*task->blk_state=BLK_TIMEOUT,表示task是由于mutex阻塞等待超时而唤醒，返回RHINO_BLK_TIMEOUT*/
        case BLK_TIMEOUT:
            status = RHINO_BLK_TIMEOUT;
            break;
        case BLK_DEL:
        	/*task->blk_state=BLK_DEL,表示task是由于mutex被DEL而唤醒，返回RHINO_BLK_DEL*/
            status = RHINO_BLK_DEL;
            break;
        default:
            k_err_proc(RHINO_BLK_INV_STATE);
            status = RHINO_BLK_INV_STATE;
            break;
    }
/*下面这两段只是根据task里的参数，返回一个合适的RHINO_TASK_CANCELED判断，不影响大局*/
#if (RHINO_CONFIG_TASK_DEL > 0)
    if (blk_obj == 0) {
        if (task->cancel == 1u) {
            status = RHINO_TASK_CANCELED;
        }
        return status;
    }

    if ((task->cancel == 1u) && (blk_obj->cancel == 1u)) {
        status = RHINO_TASK_CANCELED;
    }
#endif
    return status;
}

krhino_mutex_lock大概流程就这样分析完了，再看krhino_mutex_unlock：

kstat_t krhino_mutex_unlock(kmutex_t *mutex)
{
    CPSR_ALLOC();

    klist_t *blk_list_head;
    ktask_t *task;
    uint8_t  cur_cpu_num;

    NULL_PARA_CHK(mutex);
	//调度器未初始化的话，直接退出
    if (g_sys_stat == RHINO_STOPPED) {
        return RHINO_SUCCESS;
    }

    RHINO_CRITICAL_ENTER();
	/*判断是否是在中断中调用lock，如果是在中断中立刻返回。*/
    INTRPT_NESTED_LEVEL_CHK();
	/*判断mutex对象的类型是否真的是mutex类型*/
    if (mutex->blk_obj.obj_type != RHINO_MUTEX_OBJ_TYPE) {
        RHINO_CRITICAL_EXIT();
        return RHINO_KOBJ_TYPE_ERR;
    }
	
	//获取当前CPU号
    cur_cpu_num = cpu_cur_get();

	//check当前任务是不是获得mutex锁的任务
    /* mutex must be released by itself */
    if (g_active_task[cur_cpu_num] != mutex->mutex_task) {
        RHINO_CRITICAL_EXIT();
        return RHINO_MUTEX_NOT_RELEASED_BY_OWNER;
    }

	//到这里基本检查完毕，嵌套计数-1
    mutex->owner_nested--;

	//嵌套计数还是大于0，表示锁还不能释放，退出
    if (mutex->owner_nested > 0u) {
        RHINO_CRITICAL_EXIT();
        return RHINO_MUTEX_OWNER_NESTED;
    }

	/*这里名字虽然叫mutex_release,但是和释放锁没太大关系，
	只是将当前任务重置到一个合理的优先级，下面重点分析。*/
    mutex_release(g_active_task[cur_cpu_num], mutex);

	//查找有没有被当前mutex block的任务
    blk_list_head = &mutex->blk_obj.blk_list;
	//如果没有，可以直接退出了。
    /* if no block task on this list just return */
    if (is_klist_empty(blk_list_head)) {
    	//将mutex记录的持有mutex的任务信息删除
        /* No wait task */
        mutex->mutex_task = NULL;
		
        TRACE_MUTEX_RELEASE_SUCCESS(g_active_task[cur_cpu_num], mutex);
        RHINO_CRITICAL_EXIT();

        return RHINO_SUCCESS;
    }
	
	//如果有，找到这个被阻塞任务列表里第一个任务。
    /* there must have task blocked on this mutex object */
    task = krhino_list_entry(blk_list_head->next, ktask_t, task_list);
	
	//这里pend_task_wakeup，只是将任务放置到就绪队列，下次调度时候让调度器决定按优先级怎么跑。
    /* wake up the occupy task, which is the highst prio task on the list */
    pend_task_wakeup(task);

    TRACE_MUTEX_TASK_WAKE(g_active_task[cur_cpu_num], task, mutex);

	//将mutex给予当前这个任务，
    /* change mutex get task */
    mutex->mutex_task   = task;
#if (RHINO_CONFIG_MUTEX_INHERIT > 0)
	//让这个任务的mutex_list首先指向本mutex
    mutex->mutex_list   = task->mutex_list;
    task->mutex_list    = mutex;
#endif
	//mutex嵌套计数重新设置为1
    mutex->owner_nested = 1u;
	/*真正进行调度，这部分会在进程调度章节分析*/
    RHINO_CRITICAL_EXIT_SCHED();

    return RHINO_SUCCESS;
}

static void mutex_release(ktask_t *task, kmutex_t *mutex_rel)
{
    uint8_t new_pri;

	/*这里是要重新给当前任务重置一个优先级，这个优先级必须保证当前任务必须优于
	该任务获取的mutex_list上， 所有被block住任务的优先级。
	当然这样做的目的也是为了保证不被优先级反转。重点看mutex_pri_look
	*/
    /* find suitable task prio */
    new_pri = mutex_pri_look(task, mutex_rel);
    if (new_pri != task->prio) {
        /* change prio */
        //如果这个优先级不等于当前任务的优先级，那么重置当前任务的优先级，这样做有两个目的：
        //1. 如果当前任务因为获取到锁后，被提升过优先级，那么这个时候正好降下来
        //2. 如果当前任务获得的其他锁上，有block住比当前任务优先级更高优先级的任务，
        // 那么将当前任务优先级提升到这个任务的优先级级别，防止优先级反转的问题
        /*task_pri_change虽然挺长， 但是逻辑相对简单，就是要将task的pri设置成为new_pri*/
        task_pri_change(task, new_pri);

        TRACE_MUTEX_RELEASE(g_active_task[cpu_cur_get()], task, new_pri);

    }
}

uint8_t mutex_pri_look(ktask_t *task, kmutex_t *mutex_rel)
{
#if (RHINO_CONFIG_MUTEX_INHERIT > 0)
    kmutex_t  *mutex_tmp;
    kmutex_t **prev;
    uint8_t    new_pri;
    uint8_t    pri;
    ktask_t   *first_blk_task;
    klist_t   *blk_list_head;
	
	//new_pri 记录先当前task原始设置的优先级
    /* the base prio of task */
    new_pri = task->b_prio;

	//pri当前也记录当前task原始设置的优先级
	//prev记录task存有的第一个mutex锁
    /* the highest prio in mutex which is locked */
    pri  = new_pri;
    prev = &task->mutex_list;

	//循环遍历task拥有的所有锁
    while ((mutex_tmp = *prev) != NULL) {
    	//如果是当前mutex，则跳过
        if (mutex_tmp == mutex_rel) {
            /* delete itself from list and make task->mutex_list point to next */
            //*prev内容为task->mutex_list,也就是说task->mutex_list
            //指向的对象变为mutex_list指向的下一个mutex
            *prev = mutex_tmp->mutex_list;
            continue;
        }
		//获取被这个锁block住的第一个任务
        blk_list_head = &mutex_tmp->blk_obj.blk_list;
        if (!is_klist_empty(blk_list_head)) {
        	//如果不为空，则将pri设置为被这个锁block住的第一个任务的优先级
            first_blk_task = krhino_list_entry(blk_list_head->next, ktask_t, task_list);
            pri = first_blk_task->prio;
        }
		
		//如果new_pri优先级低于pri，则将new_pri赋值为pri（数值越高优先级越低）
        if (new_pri > pri) {
            new_pri = pri;
        }
		//跳到下一个mutex，直到NULL结束
        prev = &mutex_tmp->mutex_list;
    }

    return new_pri;
#else
    return task->b_prio;
#endif
}

kstat_t task_pri_change(ktask_t *task, uint8_t new_pri)
{
    uint8_t  old_pri;
    kmutex_t *mutex_tmp;
    ktask_t  *mutex_task;

    do {
        if (task->prio != new_pri) {
            switch (task->task_state) {
                case K_RDY:
                    ready_list_rm(&g_ready_queue, task);
                    task->prio = new_pri;
					///*如果task当前状态为K_RDY,则将task在就绪队列里重新安排:
					//如果当前运行任务就是这个task，则排到就绪队列的头上如果不是，
					//则将其安排到就绪队列的尾部 */
                    if (task == g_active_task[cpu_cur_get()]) {
                        ready_list_add_head(&g_ready_queue, task);
                    } else {
                        ready_list_add_tail(&g_ready_queue, task);
                    }

                    task = NULL;
                    break;
                /*K_SLEEP,K_SUSPENDED,K_SLEEP_SUSPENDED这三种情况的话， 直接修改pri*/
                case K_SLEEP:
                case K_SUSPENDED:
                case K_SLEEP_SUSPENDED:
                    /* set new task prio */
                    task->prio = new_pri;
                    task = NULL;
                    break;
                /*K_PEND, K_PEND_SUSPENDED这两种有阻塞性质的状态，
                又需要详细讨论（主要针对block对象为mutex的情况）*/
                case K_PEND:
                case K_PEND_SUSPENDED:
                	//old_pri记录task原来的pri
                    old_pri    = task->prio;
                    //task设置新的pri
                    task->prio = new_pri;
                    //将该任务在阻塞队列上重排
                    pend_list_reorder(task);
					//如果阻塞对象是mutex
                    if (task->blk_obj->obj_type == RHINO_MUTEX_OBJ_TYPE) {
                    	//mutex_tmp记录导致这个任务阻塞的mutex
                        mutex_tmp  = (kmutex_t *)(task->blk_obj);
                        //mutex_task为获得这个mutex的任务
                        mutex_task = mutex_tmp->mutex_task;
						//如果mutex_task的优先级小于当前任务的优先级（注意数值越大，优先级越小）
                        if (mutex_task->prio > task->prio) {
                            /* since the highest prio of the lock wait task
                            became higher, raise the lock get task prio
                            higher */
                            /*将task指向mutex_task，再经历一次循环，
                            好将mutex_task优先级也做一次适当修改。*/
                            task = mutex_task;
                        } else if (mutex_task->prio == old_pri) {
                        	/*如果mutex_task和当前task之前的优先级一样,
                        	mutex_pri_look的作用之前分析过，是为了返回一个优先级，
                        	让mutex_task的优先级，不低于mutex_task获得的锁，
                        	阻塞的其他所有任务的优先级new_pri就是这个返回的优先级*/
                            /* find suitable tcb prio */
                            new_pri = mutex_pri_look(mutex_task, 0);
							/**/
                            if (new_pri != mutex_task->prio) {
                                /* Change prio of lock get task */
                                //mutex_task优先级需要做修改
                                task = mutex_task;
                            } else {
                            	//mutex_task优先级不做修改
                                task = NULL;
                            }
                        } else {
                            task = NULL;
                        }
                    } else {
                        task = NULL;
                    }

                    break;
                default:
                    k_err_proc(RHINO_INV_TASK_STATE);
                    return RHINO_INV_TASK_STATE;
            }
        } else {
            task = NULL;
        }
    } while (task != NULL);

    return RHINO_SUCCESS;
}
void pend_list_reorder(ktask_t *task)
{
    if (task->blk_obj->blk_policy == BLK_POLICY_PRI) {
        /* remove it first and add it again in prio sorted list */
        //将该任务从原本的阻塞队列上删除
        klist_rm(&task->task_list);
        //重新按照优先级，insert到blklist上
        pend_list_add(&task->blk_obj->blk_list, task);
    }
}

最后我们再来分析一下krhino_mutex_dyn_del，这个接口是用来销毁mutex的：

kstat_t krhino_mutex_dyn_del(kmutex_t *mutex)
{
    CPSR_ALLOC();

    klist_t *blk_list_head;
	//如果mutex为空，说明之前就没申请成功，退出
    if (mutex == NULL) {
        return RHINO_NULL_PTR;
    }

    NULL_PARA_CHK(mutex);

    RHINO_CRITICAL_ENTER();
	//判断是否在中断内，是则退出。
    INTRPT_NESTED_LEVEL_CHK();
	
	//判断是否为mutex类型
    if (mutex->blk_obj.obj_type != RHINO_MUTEX_OBJ_TYPE) {
        RHINO_CRITICAL_EXIT();
        return RHINO_KOBJ_TYPE_ERR;
    }

	//判断mutex内存申请类型是否是动态的，否则不执行下面释放操作。
    if (mutex->mm_alloc_flag != K_OBJ_DYN_ALLOC) {
        RHINO_CRITICAL_EXIT();
        return RHINO_KOBJ_DEL_ERR;
    }

	//获得被该mutex block任务的链表
    blk_list_head = &mutex->blk_obj.blk_list;

    mutex->blk_obj.obj_type = RHINO_OBJ_TYPE_NONE;

	/*如果该mutex正在被其他任务获取中，则将这个获取锁的任务再安排一个合理的优先级,
	mutex_release的作用上面分析过，这里不赘述一遍了*/
    if (mutex->mutex_task != NULL) {
        mutex_release(mutex->mutex_task, mutex);
    }
	//如果被该mutex block任务不为空，则将那些任务一一取消被阻塞的状态,这些任务将重新被放到就绪队列中。
    /* all task blocked on this mutex is waken up */
    while (!is_klist_empty(blk_list_head)) {
        pend_task_rm(krhino_list_entry(blk_list_head->next, ktask_t, task_list));
    }

#if (RHINO_CONFIG_KOBJ_LIST > 0)
	//在mutex对象管理链表的挂接点上，删除本mutex
    klist_rm(&mutex->mutex_item);
#endif

    TRACE_MUTEX_DEL(g_active_task[cpu_cur_get()], mutex);
	/*真正进行调度，这部分会在进程调度章节分析*/
    RHINO_CRITICAL_EXIT_SCHED();
	/*真正free掉mutex占用的内存*/
    krhino_mm_free(mutex);

    return RHINO_SUCCESS;
}
void pend_task_rm(ktask_t *task)
{
    switch (task->task_state) {
    	 /*如果这个task在Pend状态（之前执行krhino_buf_queue_recv， krhino_mutex_lock等会block的操作）*/
        case K_PEND:
        	//将该任务从阻塞队列上删除
            /* remove task on the block list because task is waken up */
            klist_rm(&task->task_list);
             //将该任务放到就绪队列上，之后给调度器调度执行
            /*add to the ready list again*/
            ready_list_add(&g_ready_queue, task);
            //将该任务状态设置成为就绪
            task->task_state = K_RDY;
            break;
         /*如果这个task在Pend状态，并且又被挂起了*/
        case K_PEND_SUSPENDED:
        	//将该任务从阻塞队列上删除
            /* remove task on the block list because task is waken up */
            klist_rm(&task->task_list);
            //只是将该任务设置成挂起状态。
            task->task_state = K_SUSPENDED;
            break;
        default:
            k_err_proc(RHINO_SYS_FATAL_ERR);
            break;
    }
	//将该任务从定时器上删除，因为该任务已经到了就绪队列，没必要再等待定时器调度
    /* remove task on the tick list because task is waken up */
    tick_list_rm(task);
    /*该任务的blk状态设置成解除blk*/
    task->blk_state = BLK_DEL;

    /* task is nothing blocked on so reset it to NULL */
    task->blk_obj = NULL;
}

至此，mutex相关的申请，删除，占用和释放四个主要接口，我们都分析完了。可以看到，mutex的处理，很大一部分逻辑都在处理规避优先级反转的问题，在下面科普一下mutex如何会造成优先级反转问题。
——————————————————————————————————————————————
mutex锁大概的逻辑基本就是这样，最后解释一下优先级反转：

  1. 优先级反转(Priority Inversion)
    由于多进程共享资源，具有最高优先权的进程被低优先级进程阻塞，反而使具有中优先级的进程先于高优先级的进程执行，导致系统的崩溃。这就是所谓的优先级反转(Priority Inversion)。

  2. 产生原因
    其实,优先级反转是在高优级(假设为A)的任务要访问一个被低优先级任务(假设为C)占有的资源时,被阻塞.而此时又有优先级高于占有资源的任务©而低于被阻塞的任务(A)的优先级的任务(假设为B)时,于是,占有资源的任务就被挂起(占有的资源仍为它占有),因为占有资源的任务优先级很低,所以,它可能一直被另外的任务挂起.而它占有的资源也就一直不能释放,这样,引起任务A一直没办法执行.而比它优先低的任务却可以执行.

    所以,一个解决办法就是提高占有资源任务的优先级,让它正常执行,然后释放资源,以让任务A能正常获取资源而得以执行.

  3. 解决方案 ( 优先级继承 / 优先级天花板 )

    目前解决优先级反转有许多种方法。其中普遍使用的有2种方法：一种被称作优先级继承(priority inheritance)；另一种被称作优先级极限(priority ceilings)。

A. 优先级继承(priority inheritance)
优先级继承是指将低优先级任务的优先级提升到等待它所占有的资源的最高优先级任务的优先级.当高优先级任务由于等待资源而被阻塞时,此时资源的拥有者的优先级将会自动被提升.

B. 优先级天花板(priority ceilings)
优先级天花板是指将申请某资源的任务的优先级提升到可能访问该资源的所有任务中最高优先级任务的优先级.(这个优先级称为该资源的优先级天花板)

A 和B的区别:

优先级继承,只有当占有资源的低优先级的任务被阻塞时,才会提高占有资源任务的优先级,而优先级天花板,不论是否发生阻塞,都提升.
（以上优先级反转内容介绍摘录自 https://blog.csdn.net/Kendiv/article/details/1788966）
目前alios中mutex使用的是方案A，也就是优先级继承的方案。

zhang_heaven
关注
专栏目录
使用Semaphore和Mutex实现Readers-writer lock (favor writer)【STM32\RT-Thread\读写锁】
王斯聪Anson的技术博客
12-16 1955
最近一直在捣腾一个自制飞控的项目，硬件平台为STM32F4 Discovery开发板，软件平台为RT-Thread 1.1.1。我打算使用一个单独的线程采集传感器数据并存放在一个共享的buffer里，然后由多个其它线程（ 数传线程、飞行控制线程等）来读取这些数据。这就构成了一个典型的Readers-writer problem。 做编程课作业的时候曾经用过pthread的readers-
AliOS-Things+STM32 （一）运行环境搭建
zhang_heaven的专栏
02-22 3176
AliOS Things 是一款由阿里巴巴开发的轻量级物联网操作系统, 在我理解毕竟是大厂推的IOT操作系统，未来潜力巨大，所以有空实践了一下，做个专题分享。 硬件平台选了STM32板子，后续为了实践BT/WIFI会使用ESP32，都是比较经典的平台，目的就是让大家容易上手了解alios things这款系统。 Alios环境配置 首先下载alios的code： git clone https:/...
STM32 CubeMX生成FreeRTOS工程，并移植LVGL运行Demo，使用触摸屏，非无脑导入所有文件（使用LTDC和DMA2D）
最新发布
woaihetang的博客
06-28 2058
本文介绍了如何将LVGL源码移植到STM32的FreeRTOS工程下，从而方便读者进行快速开发，仅作为教学示例。操作步骤中有些操作非必要或需要读者根据实际项目情况进行修改的部分，已详细说明，望读者仔细阅读。本教程不涉及LVGL的功能裁剪，所以会将所有文件进行移植，望读者知悉。切勿在实际项目中将本教程无脑照搬！切勿在实际项目中将本教程无脑照搬！切勿在实际项目中将本教程无脑照搬！准备工作Keil已安装CubeMX已安装相应屏幕的裸机驱动程序已准备（具体实现哪些功能下面会讲）
移植Alios Things 到STM32F103C8
weixin_45806396的博客
10-29 1745
移植Alios Things 到STM32F103C8 一：开发环境搭建 1.1、配置编译环境： 您可以尝试一键安装脚本Setup Script for Linux/Mac, 或者按以下命令手动安装依赖的软件包 例：在一台 Ubuntu 16.04 LTS (Xenial Xerus) 64-bit PC 上 sudo apt-get install -y python sudo apt-get ...
AliOS-Things+STM32 （二）一个带命令行的helloworld
zhang_heaven的专栏
02-23 1267
上一篇简要的整理了一下环境搭建。一般调嵌入式代码，最好配好命令行输入，这样就能在调试的时候，方便执行固定的测试命令。Alios-Things里面已经有现成的CLI命令输入框架，只要打开相应的宏就能够直接用，我们在app/example/helloworld/Config.in中，加上select AOS_COMP_CLI，再像上一章那样，导出keil工程，编译就可以了。 --- a/app/exa...
AliOS-Things+STM32 (八) 进程管理（下）
zhang_heaven的专栏
04-11 1368
上一章，我们已经分析过一些基本的task初始化，以及让第一个task调度后运行起来了。这只是一个开始，我们还需要关注三个问题： 在SCHED_RR模式下，进程时间片消耗完毕了，怎么切换给同一优先级的另一个待运行的进程呢？ 当进程主动自己调度，调度器如何切换呢？ 当进程因为sleep/等待同步时间被block住，调度器怎么调度呢？ 带着这三个问题，我们往下看 先看下当时间片用完，也就是触发了...
mclown#AliOS-Things-wiki#AliOS-Things-uData第三方算法移植说明文档1
07-25
task_id：通过uData_new_servicetask创建的taskidms：超时时间msg：消息体size：消息大小返回值：成功0 失败非0二、Ali
AliOS-Things2.1.0-helloworld.zip
09-26
5. **外设操作**：学习如何通过AliOS Things API控制STM32L4的外设，如LED、串口通信等，进一步了解操作系统与硬件的交互。 通过这个项目，开发者不仅可以掌握AliOS Things的基本用法，还能熟悉STM32L4的开发流程，...
AliOS-Things实现图片显示及文字跳动显示
03-26
阿里云物联网操作系统AliOS Things是面向IoT领域的一款轻量级操作系统，旨在为各种智能硬件提供稳定、高效、安全的运行平台。在这个特定的场景中，“AliOS-Things实现图片显示及文字跳动显示”意味着它支持在设备的...
AliOS-Things---ESP32devkitc 操作系统开发-Doc3
ML_GearYe的博客
09-04 795
源码资源：https://github.com/Gabrielle-OyO/AliOS-Things-rel_3.1.0 项目仓库：https://github.com/Gabrielle-OyO/AliOS-Things-Term 1、下载相应软件完成AliOS开发环境的搭建，并成功编译helloworld例程，将环境搭建过程及程序运行结果截图，并简单分析该程序所实现的功能。 这里使用XCOM串口监视器:https://github.com/Gabrielle-OyO/AliOS-Things..
Alios-Things之wifi模块二次开发-(1)搭建Alios-Things开发环境(基于ubuntu 16.0.4)
lizhibo32的博客
09-01 2678
一、安装流程如下：     1.先安装VSCode，保证有个可视的编辑器；      2.然后安装aos-cube,是编译工具；      3.最后安装git工具，下载Alios-Things国内托管仓库代码。      4.基于庆科MK3080和乐鑫ESP8266编译最简单的helloworld工程。 二、安装明细：     1.安装VSCode     搜索网上参考方法如下： ...
互斥锁与事件锁
02-26
里面详细介绍了互斥锁与事件锁，内有DEMO，并介绍了事件锁的两种方式的对比
AliOS Things入门(1) 基于STM32L4与MDK搭建AliOS Things2.1.0开发环境
nich2009的专栏
06-03 7829
基于STM32L4与MDK搭建AliOS Things开发环境 1 前言 随着2016年NB-IoT技术标准的冻结，带动物联网（IoT）整个领域的快速发展，并将在2017~2021期间将持续火爆。同时随着大数据、云计算、IoT技术等进一步发展与成熟、芯片存储成本的降低、IoT应用的快速普及等等，物联网RTOS作为IoT设备的基础软件，在一定程度上可以破解物联网下游的碎片化困局，加快下游物联网应用...
使用Jlink调试基于AliOS-Things的stm32
金叶子
07-21 1626
使用Jlink调试基于AliOS-Things的stm32 一、原因 ​ 在准备玩AliOS-Things的时候，发现它里面提供的stm32的调试例子，都是用的stlink。 二、环境搭建 ​ 请参考官方文档。 三、使用Jlink调试 ​ 现在手里有一块stm32f4的开发板，型号是stm32f407，因为这里只是为了说明怎么使用Jlink进行调试，所以只需选一个相似的board...
AliOS-Things+STM32 (四) 同步机制（buf_queue）
zhang_heaven的专栏
03-03 1211
Alios中的buf_queue，相当于Freertos中的msg queue，是一种很常用的消息同步机制，
AliOS-Things+STM32 (五) 堆内存管理（上）
zhang_heaven的专栏
03-14 1542
开发过程中，写代码用得最多的就是对堆的malloc和free了， 在alios这样的小系统中，我们看下是如何处理堆内存的。 跟堆内存相关的有如下几个宏： RHINO_CONFIG_MM_TLF RHINO_CONFIG_MM_BLK RHINO_CONFIG_MM_TLF_BLK_SIZE RHINO_CONFIG_MM_DEBUG 其中RHINO_CONFIG_MM_BLK和RHINO_CO...
CMSIS Example - osMutex osMutexWait osMutexRelease
weixin_33943836的博客
07-18 1743
osMutexDef( Mutex ); osMutexId mutex; void Thread0( void * arg); void Thread1( void * arg); osThreadDef( Thread0, Thread0, osPriorityNormal, 512 ); osThreadDef( Thread1, Thread1, osPriority...
点亮AliOS Things IOT(STM32L496VGTx)开发板上的的ST7789 OLED全彩屏
Bruce.yang的嵌入式之旅
10-03 2677
我用的是下面这个板子: 如图所示，这个板子的OLED驱动在开源例程里给出，但是不是基于Keil MDK来开发的，只是用CubeMX生成了对应的驱动源码，现在我将它的驱动移植到Keil MDK上来。 屏的代码可以参考：https://github.com/alibaba/AliOS-Things/tree/rel_3.0.0/app/example/dk/dk_gui 以下是我参考这个源代码移植出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值