ESP32移植Openharmony设备开发---(6)Mutex互斥锁

发布于:2024-10-18 ⋅ 阅读:(35) ⋅ 点赞:(0)

Mutex互斥锁

官方文档:OpenAtom OpenHarmony

基本概念

互斥锁又称互斥型信号量,用于实现对共享资源的独占式处理。当有任务持有时,这个任务获得该互斥锁的所有权。当该任务释放它时,任务失去该互斥锁的所有权。当一个任务持有互斥锁时,其他任务将不能再持有该互斥锁。多任务环境下往往存在多个任务竞争同一共享资源的应用场景,互斥锁可被用于对共享资源的保护从而实现独占式访问。

互斥锁属性包含3个属性:协议属性、优先级上限属性和类型属性。协议属性用于处理不同优先级的任务申请互斥锁,协议属性包含如下三种:

  • LOS_MUX_PRIO_NONE 不对申请互斥锁的任务的优先级进行继承或保护操作。
  • LOS_MUX_PRIO_INHERIT 优先级继承属性,默认设置为该属性,对申请互斥锁的任务的优先级进行继承。在互斥锁设置为本协议属性情况下,申请互斥锁时,如果高优先级任务阻塞于互斥锁,则把持有互斥锁任务的优先级备份到任务控制块的优先级位图中,然后把任务优先级设置为和高优先级任务相同的优先级;持有互斥锁的任务释放互斥锁时,从任务控制块的优先级位图恢复任务优先级。
  • LOS_MUX_PRIO_PROTECT 优先级保护属性,对申请互斥锁的任务的优先级进行保护。在互斥锁设置为本协议属性情况下,申请互斥锁时,如果任务优先级小于互斥锁优先级上限,则把任务优先级备份到任务控制块的优先级位图中,然后把任务优先级设置为互斥锁优先级上限属性值;释放互斥锁时,从任务控制块的优先级位图恢复任务优先级。

互斥锁的类型属性用于标记是否检测死锁,是否支持递归持有,类型属性包含如下三种:

  • LOS_MUX_NORMAL 普通互斥锁,不会检测死锁。如果任务试图对一个互斥锁重复持有,将会引起这个线程的死锁。如果试图释放一个由别的任务持有的互斥锁,或者如果一个任务试图重复释放互斥锁都会引发不可预料的结果。
  • LOS_MUX_RECURSIVE 递归互斥锁,默认设置为该属性。在互斥锁设置为本类型属性情况下,允许同一个任务对互斥锁进行多次持有锁,持有锁次数和释放锁次数相同,其他任务才能持有该互斥锁。如果试图持有已经被其他任务持有的互斥锁,或者如果试图释放已经被释放的互斥锁,会返回错误码。
  • LOS_MUX_ERRORCHECK 错误检测互斥锁,会自动检测死锁。在互斥锁设置为本类型属性情况下,如果任务试图对一个互斥锁重复持有,或者试图释放一个由别的任务持有的互斥锁,或者如果一个任务试图释放已经被释放的互斥锁,都会返回错误码。

运行机制

多任务环境下会存在多个任务访问同一公共资源的场景,而有些公共资源是非共享的,需要任务进行独占式处理。互斥锁怎样来避免这种冲突呢?

用互斥锁处理非共享资源的同步访问时,如果有任务访问该资源,则互斥锁为加锁状态。此时其他任务如果想访问这个公共资源则会被阻塞,直到互斥锁被持有该锁的任务释放后,其他任务才能重新访问该公共资源,此时互斥锁再次上锁,如此确保同一时刻只有一个任务正在访问这个公共资源,保证了公共资源操作的完整性。

小型系统互斥锁运作示意图

BUILD.gn

# Copyright (c) 2022 Hunan OpenValley Digital Industry Development Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import("//kernel/liteos_m/liteos.gni")

module_name = get_path_info(rebase_path("."), "name")
kernel_module(module_name){
    sources = [
        "LOS_Mutex_example.c"
    ]
    
    include_dirs = [
        "//kernel/liteos_m/kernel/include"
    ]
}

LOS_Mutex_example

/*
 * Copyright (c) 2022 Hunan OpenValley Digital Industry Development Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include "los_event.h"
#include "los_mux.h"
#include "los_task.h"
#include "ohos_run.h"

#ifndef osWaitForever
#define osWaitForever 0xFFFFFFFFU
#endif

#define EVENT_MASK_CLEAN 0x00000001
#define MAX_STR_LEN 256
#define DELAY_100_TICKS 100U
#define DELAY_400_TICKS (4 * DELAY_100_TICKS)
#define DELAY_600_TICKS (6 * DELAY_100_TICKS)
#define TASK_STACK_SIZE 4096
#define TASK_PRIO 5

UINT32 mutex1_id;
UINT32 mutex2_id;

static char g_str[MAX_STR_LEN];

void firstThread(UINT32 arg)
{
    int ret = -1;
    while (1) {
        LOS_MuxPend(mutex1_id, osWaitForever);
        ret = strcpy_s(g_str, MAX_STR_LEN, "firstThread");
        if (ret != 0) {
            printf("strcpy_s fail!\r\n");
        }
        printf("firstThread is Acquire. g_str=%s\r\n", g_str);
        LOS_MuxPost(mutex1_id);
        LOS_TaskDelay(DELAY_100_TICKS);
    }
}

void secondThread(UINT32 arg)
{
    int ret = -1;
    while (1) {
        LOS_MuxPend(mutex2_id, osWaitForever);
        char tmp[MAX_STR_LEN] = {0};
        ret = sprintf_s(tmp, MAX_STR_LEN, "%s+secondThread", g_str);
        if (ret < 0) {
            printf("sprintf_s fail!\r\n");
        }

        ret = memcpy_s(g_str, MAX_STR_LEN, tmp, sizeof(tmp));
        if (ret != 0) {
            printf("memcpy_s fail!\r\n");
        }
        printf("secondThread is Acquire. g_str=%s\r\n", g_str);
        LOS_MuxPost(mutex2_id);
        LOS_TaskDelay(DELAY_100_TICKS);
    }
}

void thirdThread(UINT32 arg)
{
    int ret;
    while (1) {
        LOS_MuxPend(mutex1_id, osWaitForever);
        LOS_MuxPend(mutex2_id, osWaitForever);
        char tmp[MAX_STR_LEN] = {0};
        ret = sprintf_s(tmp, MAX_STR_LEN, "%s+thirdThread", g_str);
        if (ret < 0) {
            printf("sprintf_s fail!\r\n");
        }

        ret = memcpy_s(g_str, MAX_STR_LEN, tmp, sizeof(tmp));
        if (ret != 0) {
            printf("memcpy_s fail!\r\n");
        }
        printf("thirdThread is Acquire. g_str=%s\r\n", g_str);
        LOS_TaskDelay(DELAY_100_TICKS);
        LOS_MuxPost(mutex1_id);
        LOS_TaskDelay(DELAY_400_TICKS);
        LOS_MuxPost(mutex2_id);
        LOS_TaskDelay(DELAY_600_TICKS);
    }
}

void os_mutex_example(void)
{
    int ret = -1;
    ret = memset_s(g_str, MAX_STR_LEN, 0, MAX_STR_LEN);
    if (ret != 0) {
        printf("memset_s fail!\r\n");
    }
    TSK_INIT_PARAM_S attr = {0};
    attr.uwStackSize = TASK_STACK_SIZE;
    attr.usTaskPrio = TASK_PRIO;

    // 创建互斥锁
    if (LOS_MuxCreate(&mutex1_id) != LOS_OK) {
        printf("create Mutex1 failed!  ret=%x\n", ret);
        return;
    }

    if (LOS_MuxCreate(&mutex2_id) != LOS_OK) {
        printf("create Mutex2 failed!\n");
        LOS_MuxDelete(mutex1_id);
        return;
    }

    // 锁任务调度
    LOS_TaskLock();
    attr.pcName = "firstThread";
    attr.pfnTaskEntry = (TSK_ENTRY_FUNC)firstThread;
    UINT32 taskIDFirst;
    if (LOS_TaskCreate(&taskIDFirst, &attr) != LOS_OK) {
        printf("create firstThread failed!\n");
        LOS_MuxDelete(mutex1_id);
        LOS_MuxDelete(mutex2_id);
        return;
    }
    attr.pcName = "secondThread";
    attr.pfnTaskEntry = (TSK_ENTRY_FUNC)secondThread;
    UINT32 taskIDTwo;
    if (LOS_TaskCreate(&taskIDTwo, &attr) != LOS_OK) {
        printf("create secondThread failed!\n");
    }
    attr.pcName = "thirdThread";
    attr.pfnTaskEntry = (TSK_ENTRY_FUNC)thirdThread;
    UINT32 taskIDThree;
    if (LOS_TaskCreate(&taskIDThree, &attr) != LOS_OK) {
        printf("create thirdThread failed!\n");
    }
    LOS_TaskUnlock(); // 解锁任务调度
}

OHOS_APP_RUN(os_mutex_example);

代码分析:

  • firstThread|secondThread|、thirdThread:循环中尝试获取mutex1_id,然后修改g_str的值,添加上自己的标识,并打印当前线程获得互斥锁后的g_str值。释放互斥锁并延时一段时间。

互斥锁同步行为分析

  • firstThreadsecondThread 分别对不同的互斥锁进行操作(互斥锁id不同),所以可以并行执行
  • thirdThread 则需要同时获得两个互斥锁,这意味着它将在其他两个任务释放各自的互斥锁后才能继续执行。这种情况下,thirdThread 的执行会依赖于firstThreadsecondThread 的进度。

API参考

LOS_MuxCreate()
UINT32 LOS_MuxCreate(UINT32 *muxHandle);

描述:

创建互斥锁

参数:

名字

描述

muxHandle

互斥锁id

LOS_MuxPend()
UINT32 LOS_MuxPend(UINT32 muxHandle, UINT32 timeout);

描述:

获取互斥锁

参数:

名字

描述

muxHandle

互斥锁id,由LOS_MuxCreate创建得到

timeout

delay时间

LOS_MuxPost()
UINT32 LOS_MuxPost(UINT32 muxHandle);

描述:

释放互斥锁

参数:

名字

描述

muxHandle

互斥锁id,由LOS_MuxCreate创建得到

LOS_MuxDelete()
UINT32 LOS_MuxDelete(UINT32 muxHandle);

描述:

删除互斥锁

参数:

名字

描述

muxHandle

互斥锁id,由LOS_MuxCreate创建得到

编译并烧录

修改工作文件夹级的BUILD.gn文件,将编译的文件夹指定为新建的005_LOS_Mutex

在源码根目录下使用hb工具对写好的代码进行编译

选择mini级系统

同理 产品选择esp公司下的esp32

选择完毕后在源码根目录下执行hb build -f 进行编译

编译完成后会有如下界面,并且编译后的代码固件位于:out\esp32\esp32

验证结果

打开串口工具->选择COM5->打开串口

按下ESP32开发板上的EN键,即可观察到实验现象:


网站公告

今日签到

点亮在社区的每一天
去签到