KRTS使用互斥锁同步

使用互斥锁同步

QuickMutex 是一个同步对象，它针对高效执行进行了优化。但它可以在应用程序级别上保护不同的程序部分，也可以在内核级别保护不同的程序部分！使用 QuickMutex 对象无法实现应用程序级和内核级之间的同步！

创建 QuickMutex 对象

将使用 KS_createQuickMutex 创建一个 QuickMutex 对象。参数 level 决定此互斥锁可以在哪个级别工作。级别为(按升序排列)：‘KS_APP_LEVEL’、‘KS_DPC_LEVEL’、‘KS_ISR_LEVEL’、‘KS_RTX_LEVEL’、‘KS_CPU_LEVEL’。

较高的级别可以锁定自己的级别，较小的级别可以锁定较高的级别。因此，使用级别"KS_ISR_LEVEL"创建的 QuickMutex 可以锁定"KS_APP_LEVEL"、“KS_DPC_LEVEL"和"KS_ISR_LEVEL”，但不能锁定"KS_RTX_LEVEL"或"KS_CPU_LEVEL"。有关更多级别详细信息，请参阅 KS_createQuickMutex。

此外，参数 flags 必须设置为"KSF_USER_EXEC"或"KSF_KERNEL_EXEC"。要锁定在任务上下文中运行的代码，请使用"KSF_KERNEL_EXEC"。要锁定在线程上下文中运行的代码，请使用"KSF_USER_EXEC"。

注意： 要确保最佳实时行为，请使用您真正需要的级别。更高级别的 Quickmutex-objects 使用可以影响系统抖动的机制。

功能

QuickMutex 对象同时提供"request"和"release"操作。对象的初始状态为"释放"。为了访问必须由 QuickMutex 保护的资源，将使用函数 KS_requestQuickMutex 请求它。如果它是空闲的，则没有其他代码部分请求 QuickMutex，该函数会立即返回，并且现在请求 QuickMutex。否则，只要资源是"请求"的，当前代码部分就会被阻止。"请求的"QuickMutex 随 KS_releaseQuickMutex 一起发布。

代码实例

main.cpp

#include <cstdio>
#include <Windows.h>
#include <vector>
#include "KrtsDemo.h"

const char customerNumber[256] = "DEMO";
std::vector<int> vector_;
KSHandle mutex_handle_;

void OutputErr(KSError error, const char* pFuncName, const char* pComment)
{
    if (error == KS_OK)
        return;

    const char* pError;
    KS_getErrorString(error, &pError, KSLNG_DEFAULT);
    printf("ERROR (%08X = \'%s\') -  %s: %s\n", error, pError, pFuncName, pComment);
}

// 线程
KSError _stdcall MyThread(void* pArgs)
{
    KS_requestQuickMutex(mutex_handle_);
    for (int i = 0; i < 10; i++)
    {
        vector_.push_back(i);
        printf("MyThread %d\n", i);
        Sleep(100);
    }
    KS_releaseQuickMutex(mutex_handle_);
    return KS_OK;
}

int main()
{
    KSError error;
    error = KS_openDriver(customerNumber);	// 所有KRTS项目的第一步
    if (error != KS_OK)
    {
        error = 1;
        OutputErr(error, "KS_openDriver", "Unable to open the driver!");

    }
    else
    {
        printf("Hello KRTS! \n");
    }

    // 创建互斥锁
    error = KS_createQuickMutex(&mutex_handle, KS_APP_LEVEL, KSF_USER_EXEC);
    if (error != KS_OK)
    {
        OutputErr(error,"KS_createQuickMutex", "exec failed");
        return error;
    }

    // 创建线程
    error = KS_createThread(MyThread, nullptr, nullptr);
    if (error != KS_OK)
    {
        OutputErr(error, "KS_createThread", "create thread failed");
        KS_closeDriver();
        return 0;
    }

    // 获取锁
    Sleep(10);      // 确保线程先执行
    KS_requestQuickMutex(mutex_handle_);
    for (const auto& i : vector_)
    {
        printf("MainThread %d\n", i);
    }
    KS_releaseQuickMutex(mutex_handle_);

    // 释放锁
    if (mutex_handle_ != NULL)
    {
        KS_removeQuickMutex(mutex_handle_);
    }

    // 关闭驱动
    error = KS_closeDriver();
    if (error != KS_OK)
    {
        OutputErr(error, "KS_closeDriver", "");
        KS_closeDriver();
        return 0;
    }
    Sleep(1000);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91