菜单
互斥锁mutex
POSIX 风格的互斥服务。
详细描述
POSIX 风格的互斥服务。
互斥锁是一个 MUTual EXclusion 对象，用于保护共享数据结构免受并发修改，并实现临界区和监视器。
互斥锁有两种可能的状态：未锁定（未被任何任务拥有）和已锁定（被一个任务拥有）。互斥锁永远不能同时被两个不同的任务拥有。尝试锁定已被其他任务锁定的互斥锁的任务将被阻塞，直到后者先解锁互斥锁。
rkernel 互斥服务强制执行优先级继承协议以解决优先级反转问题。
函数文档
aori_mutex_acquire
int aori_mutex_acquire (AORI_RT_MUTEX *mutex, AORI_RT_TIME timeout);
获取/锁定互斥锁（具有相对标量超时）。
此例程是 aori_mutex_acquire_timed() 的一个变体，接受以标量值表示的相对超时规范。
参数
- mutex 互斥锁描述符。
- timeout 以时钟刻度表示的延迟。传递 TM_INFINITE 会导致调用者无限期阻塞。传递 TM_NONBLOCK 会导致服务在互斥锁已被其他任务锁定的情况下立即返回，而不会阻塞。
标签
xthread-only, switch-primary
{{% details title="示例代码" closed="true" %}}
c{filename="app.c"}
复制代码
#include <aori/rt/mutex.h>
#include <aori/rt/task.h>
#include <stdio.h>
#include <stdlib.h>
#define TASK_PRIO 50
#define TASK_MODE AORI_RT_TASK_MODE_JOINABLE
#define TASK_STKSZ 0
AORI_RT_MUTEX mutex;
int shared_resource = 0;
void task_function(void *arg) {
int task_id = (int)(long)arg; // NOLINT
int ret;
printf("Task %d: Try to acquire mutex...\n", task_id);
ret = aori_mutex_acquire(&mutex, AORI_RT_TM_INFINITE);
if (ret) {
fprintf(stderr, "Task: aori_mutex_acquire %s\n", strerror(-ret));
return;
}
printf("Task %d: Successfully acquired the mutex\n", task_id);
// 访问共享资源
shared_resource++;
printf("Task %d: Increase the shared resource value to %d\n", task_id, shared_resource);
// 模拟工作
aori_task_sleep(1000000000); // 睡眠1秒
printf("Task %d: Release the mutex\n", task_id);
ret = aori_mutex_release(&mutex);
if (ret) {
fprintf(stderr, "Task: aori_mutex_release %s\n", strerror(-ret));
}
}
int main(int argc, char *argv[]) {
AORI_RT_TASK task1, task2;
int ret;
// 创建互斥锁
ret = aori_mutex_create(&mutex, "MyMutex");
if (ret) {
fprintf(stderr, "Task: aori_mutex_create %s\n", strerror(-ret));
return EXIT_FAILURE;
}
// 创建任务1
ret = aori_task_create(&task1, "Task1", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
return EXIT_FAILURE;
}
// 创建任务2
ret = aori_task_create(&task2, "Task2", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
return EXIT_FAILURE;
}
// 启动任务
aori_task_start(&task1, &task_function, (void *)1); // NOLINT
aori_task_start(&task2, &task_function, (void *)2); // NOLINT
// 等待任务完成
aori_task_join(&task1);
aori_task_join(&task2);
// 清理
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
aori_task_delete(&task2);
printf("Final shared resource value: %d\n", shared_resource);
return EXIT_SUCCESS;
}{{% /details %}}
aori_mutex_acquire_timed
int aori_mutex_acquire_timed (AORI_RT_MUTEX *mutex, const struct timespec *abs_timeout);
获取/锁定互斥锁（具有绝对超时日期）。
尝试锁定互斥锁。调用任务被阻止，直到互斥锁可用，在这种情况下，它会在该服务返回之前再次被锁定。rkernel 互斥锁是隐式递归的，并实现优先级继承协议。
参数
- mutex 互斥锁描述符。
- abs_timeout 一个以秒/纳秒表示的绝对日期，基于 Alchemy 时钟，指定等待从堆中获取请求大小的块的时间限制。传递 NULL 会导致调用者无限期阻塞，直到有块可用。传递 { .tv_sec = 0, .tv_nsec = 0 } 会导致服务在块不可用的情况下立即返回，而不会阻塞。
返回值
成功时返回零。否则：
- 如果在互斥锁可用之前达到 abs_timeout，则返回 ETIMEDOUT。
- 如果超时为 { .tv_sec = 0, .tv_nsec = 0 } 并且互斥锁不是立即可用，则返回 EWOULDBLOCK。
- 如果为当前任务调用了 aori_task_unblock()，则返回 EINTR。
- 如果互斥锁不是有效的互斥锁描述符，则返回 EINVAL。
- 如果在调用者等待互斥锁时将其删除，则返回 EIDRM。在这种情况下，互斥锁在该服务返回时不再有效。
- 如果此服务应该阻塞但不是从一个 rkernel 线程调用，则返回 EPERM。
标签
xthread-only, switch-primary
{{% details title="示例代码" closed="true" %}}
c{filename="app.c"}
复制代码
#include <aori/rt/mutex.h>
#include <aori/rt/task.h>
#include <aori/nrt/clock.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#define TASK_PRIO 50
#define TASK_MODE AORI_RT_TASK_MODE_JOINABLE
#define TASK_STKSZ 0
AORI_RT_MUTEX mutex;
int shared_resource = 0;
void task_function(void *arg) {
int task_id = (int)(long)arg; // NOLINT
int ret;
printf("Task %d: Try to acquire mutex...\n", task_id);
struct timespec ts;
aori_nrt_clock_gettime(CLOCK_MONOTONIC, &ts);
ts.tv_sec += 2; // 2 seconds
ret = aori_mutex_acquire_timed(&mutex, &ts);
if (ret) {
fprintf(stderr, "Task: aori_mutex_acquire %s\n", strerror(-ret));
return;
}
printf("Task %d: Successfully acquired the mutex\n", task_id);
// 访问共享资源
shared_resource++;
printf("Task %d: Increase the shared resource value to %d\n", task_id, shared_resource);
// 模拟工作
aori_task_sleep(1000000000); // 睡眠1秒
printf("Task %d: Release the mutex\n", task_id);
ret = aori_mutex_release(&mutex);
if (ret) {
fprintf(stderr, "Task: aori_mutex_release %s\n", strerror(-ret));
}
}
int main(int argc, char *argv[]) {
AORI_RT_TASK task1, task2;
int ret;
// 创建互斥锁
ret = aori_mutex_create(&mutex, "MyMutex");
if (ret) {
fprintf(stderr, "Task: aori_mutex_create %s\n", strerror(-ret));
return EXIT_FAILURE;
}
// 创建任务1
ret = aori_task_create(&task1, "Task1", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
return EXIT_FAILURE;
}
// 创建任务2
ret = aori_task_create(&task2, "Task2", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
return EXIT_FAILURE;
}
// 启动任务
aori_task_start(&task1, &task_function, (void *)1); // NOLINT
aori_task_start(&task2, &task_function, (void *)2); // NOLINT
// 等待任务完成
aori_task_join(&task1);
aori_task_join(&task2);
// 清理
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
aori_task_delete(&task2);
printf("Final shared resource value: %d\n", shared_resource);
return EXIT_SUCCESS;
}{{% /details %}}
aori_mutex_acquire_until
int aori_mutex_acquire_until (AORI_RT_MUTEX *mutex, AORI_RT_TIME timeout);
获取/锁定互斥锁（具有绝对标量超时）。
此例程是 aori_mutex_acquire_timed() 的变体，接受以标量值表示的绝对超时规范。
参数
- mutex 互斥锁描述符。
- abs_timeout 以时钟滴答表示的绝对日期。传递 TM_INFINITE 可使调用者无限期阻塞。传递 TM_NONBLOCK 可使服务立即返回而不阻塞，以防互斥锁已被其他任务锁定。
标签
xthread-only, switch-primary
{{% details title="示例代码" closed="true" %}}
c{filename="app.c"}
复制代码
#include <aori/rt/mutex.h>
#include <aori/rt/task.h>
#include <aori/nrt/clock.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#define TASK_PRIO 50
#define TASK_MODE AORI_RT_TASK_MODE_JOINABLE
#define TASK_STKSZ 0
AORI_RT_MUTEX mutex;
int shared_resource = 0;
void task_function(void *arg) {
int task_id = (int)(long)arg; // NOLINT
int ret;
printf("Task %d: Try to acquire mutex...\n", task_id);
AORI_RT_TIME timeout = aori_timer_read() + 2000000000; // 2 seconds
ret = aori_mutex_acquire_until(&mutex, timeout);
if (ret) {
fprintf(stderr, "Task: aori_mutex_acquire %s\n", strerror(-ret));
return;
}
printf("Task %d: Successfully acquired the mutex\n", task_id);
// 访问共享资源
shared_resource++;
printf("Task %d: Increase the shared resource value to %d\n", task_id, shared_resource);
// 模拟工作
aori_task_sleep(1000000000); // 睡眠1秒
printf("Task %d: Release the mutex\n", task_id);
ret = aori_mutex_release(&mutex);
if (ret) {
fprintf(stderr, "Task: aori_mutex_release %s\n", strerror(-ret));
}
}
int main(int argc, char *argv[]) {
AORI_RT_TASK task1, task2;
int ret;
// 创建互斥锁
ret = aori_mutex_create(&mutex, "MyMutex");
if (ret) {
fprintf(stderr, "Task: aori_mutex_create %s\n", strerror(-ret));
return EXIT_FAILURE;
}
// 创建任务1
ret = aori_task_create(&task1, "Task1", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
return EXIT_FAILURE;
}
// 创建任务2
ret = aori_task_create(&task2, "Task2", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
return EXIT_FAILURE;
}
// 启动任务
aori_task_start(&task1, &task_function, (void *)1); // NOLINT
aori_task_start(&task2, &task_function, (void *)2); // NOLINT
// 等待任务完成
aori_task_join(&task1);
aori_task_join(&task2);
// 清理
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
aori_task_delete(&task2);
printf("Final shared resource value: %d\n", shared_resource);
return EXIT_SUCCESS;
}{{% /details %}}
aori_mutex_bind
int aori_mutex_bind (AORI_RT_MUTEX *mutex, const char *name, AORI_RT_TIME timeout);
绑定到一个互斥锁。
此例程创建一个新的描述符来引用由其符号名称标识的现有互斥锁。如果在入口处对象不存在，调用者可能会阻塞，直到创建了给定名称的互斥锁。
参数
- mutex 由操作填充的互斥锁描述符的地址。失败时，此内存的内容是未定义的。
- name 一个有效的以 NULL 结尾的名称，用于标识要绑定的互斥锁。此字符串应与传递给 aori_mutex_create() 的对象名称参数匹配。
- timeout 等待注册发生的时钟刻度数（见注）。传递 TM_INFINITE 会导致调用者无限期阻塞，直到对象被注册。传递 TM_NONBLOCK 会导致服务在对象在入口处未注册时立即返回，而不等待。
返回值
成功时返回零。否则：
- 如果在检索完成之前为当前任务调用了 aori_task_unblock()，则返回 -EINTR。
- 如果 timeout 等于 TM_NONBLOCK 并且在入口处未注册搜索的对象，则返回 -EWOULDBLOCK。
- 如果无法在指定的时间内检索到对象，则返回 -ETIMEDOUT。
- 如果此服务应阻塞，但未从 rkernel 线程调用，则返回 -EPERM。
标签
xthread-nowait, switch-primary
注意
超时值被解释为 Alchemy 时钟分辨率的倍数（参见 -alchemy-clock-resolution 选项，默认为 1 纳秒）。
{{% details title="示例代码" closed="true" %}}
c{filename="app.c"}
复制代码
#include <aori/rt/mutex.h>
#include <aori/rt/task.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TASK_PRIO 50
#define TASK_MODE AORI_RT_TASK_MODE_JOINABLE
#define TASK_STKSZ 0
AORI_RT_MUTEX mutex;
int shared_resource = 0;
void task_function(void *arg) {
int task_id = (int)(long)arg; // NOLINT
int ret;
AORI_RT_MUTEX mutex_task;
ret = aori_mutex_bind(&mutex_task, "MyMutex", AORI_RT_TM_INFINITE);
if (ret) {
fprintf(stderr, "Task: aori_mutex_bind %s\n", strerror(-ret));
return;
}
printf("Task %d: Try to acquire mutex...\n", task_id);
ret = aori_mutex_acquire(&mutex_task, AORI_RT_TM_INFINITE);
if (ret) {
fprintf(stderr, "Task: aori_mutex_acquire %s\n", strerror(-ret));
return;
}
printf("Task %d: Successfully acquired the mutex\n", task_id);
// 访问共享资源
shared_resource++;
printf("Task %d: Increase the shared resource value to %d\n", task_id, shared_resource);
// 模拟工作
aori_task_sleep(1000000000); // 睡眠1秒
printf("Task %d: Release the mutex\n", task_id);
ret = aori_mutex_release(&mutex_task);
if (ret) {
fprintf(stderr, "Task: aori_mutex_release %s\n", strerror(-ret));
}
aori_mutex_unbind(&mutex_task);
}
int main(int argc, char *argv[]) {
AORI_RT_TASK task1, task2;
int ret;
// 创建互斥锁
ret = aori_mutex_create(&mutex, "MyMutex");
if (ret) {
fprintf(stderr, "Task: aori_mutex_create %s\n", strerror(-ret));
return EXIT_FAILURE;
}
// 创建任务1
ret = aori_task_create(&task1, "Task1", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
return EXIT_FAILURE;
}
// 创建任务2
ret = aori_task_create(&task2, "Task2", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
return EXIT_FAILURE;
}
// 启动任务
aori_task_start(&task1, &task_function, (void *)1); // NOLINT
aori_task_start(&task2, &task_function, (void *)2); // NOLINT
// 等待任务完成
aori_task_join(&task1);
aori_task_join(&task2);
// 清理
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
aori_task_delete(&task2);
printf("Final shared resource value: %d\n", shared_resource);
return EXIT_SUCCESS;
}{{% /details %}}
aori_mutex_create
int aori_mutex_create (AORI_RT_MUTEX *mutex, const char *name);
创建一个互斥锁。
创建一个互斥对象，允许多个任务同步访问共享资源。互斥锁在创建后处于未锁定状态。
参数
- mutex 互斥锁描述符的地址，成功创建后可用于唯一标识该对象。
- name 一个代表互斥锁符号名称的 ASCII 字符串。当非 NULL 和非空时，此字符串的副本用于将创建的互斥锁索引到对象注册表中。
返回值
成功时返回零。否则：
- 如果系统无法从主堆获取内存以创建互斥锁，则返回 -ENOMEM。
- 如果名称与已注册的互斥锁冲突，则返回 -EEXIST。
- 如果此服务是从无效的上下文调用的，例如中断或非 rkernel 线程，则返回 -EPERM。
标签
xthread-only, mode-unrestricted, switch-secondary
注意
属于同一 rkernel 会话的多个进程可以共享互斥锁。
{{% details title="示例代码" closed="true" %}}
c{filename="app.c"}
复制代码
#include <aori/rt/mutex.h>
#include <aori/rt/task.h>
#include <stdio.h>
#include <stdlib.h>
#define TASK_PRIO 50
#define TASK_MODE AORI_RT_TASK_MODE_JOINABLE
#define TASK_STKSZ 0
AORI_RT_MUTEX mutex;
int shared_resource = 0;
void task_function(void *arg) {
int task_id = (int)(long)arg; // NOLINT
int ret;
printf("Task %d: Try to acquire mutex...\n", task_id);
ret = aori_mutex_acquire(&mutex, AORI_RT_TM_INFINITE);
if (ret) {
fprintf(stderr, "Task: aori_mutex_acquire %s\n", strerror(-ret));
return;
}
printf("Task %d: Successfully acquired the mutex\n", task_id);
// 访问共享资源
shared_resource++;
printf("Task %d: Increase the shared resource value to %d\n", task_id, shared_resource);
// 模拟工作
aori_task_sleep(1000000000); // 睡眠1秒
printf("Task %d: Release the mutex\n", task_id);
ret = aori_mutex_release(&mutex);
if (ret) {
fprintf(stderr, "Task: aori_mutex_release %s\n", strerror(-ret));
}
}
int main(int argc, char *argv[]) {
AORI_RT_TASK task1, task2;
int ret;
// 创建互斥锁
ret = aori_mutex_create(&mutex, "MyMutex");
if (ret) {
fprintf(stderr, "Task: aori_mutex_create %s\n", strerror(-ret));
return EXIT_FAILURE;
}
// 创建任务1
ret = aori_task_create(&task1, "Task1", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
return EXIT_FAILURE;
}
// 创建任务2
ret = aori_task_create(&task2, "Task2", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
return EXIT_FAILURE;
}
// 启动任务
aori_task_start(&task1, &task_function, (void *)1); // NOLINT
aori_task_start(&task2, &task_function, (void *)2); // NOLINT
// 等待任务完成
aori_task_join(&task1);
aori_task_join(&task2);
// 清理
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
aori_task_delete(&task2);
printf("Final shared resource value: %d\n", shared_resource);
return EXIT_SUCCESS;
}{{% /details %}}
aori_mutex_delete
int aori_mutex_delete (AORI_RT_MUTEX *mutex);
删除一个互斥锁。
此例程删除由 aori_mutex_create() 调用先前创建的互斥对象。
参数
- mutex 互斥锁描述符。
返回值
成功时返回零。否则：
- 如果 mutex 不是有效的互斥锁描述符，则返回 -EINVAL。
- 如果此服务是从异步上下文调用的，则返回 -EPERM。
- 如果尝试销毁由 mutex 引用的对象时，该对象仍被引用（例如，另一个任务正在使用 aori_mutex_acquire()、aori_mutex_acquire_timed() 或 aori_mutex_acquire_until()），则返回 -EBUSY。
标签
mode-unrestricted, switch-secondary
{{% details title="示例代码" closed="true" %}}
c{filename="app.c"}
复制代码
#include <aori/rt/mutex.h>
#include <aori/rt/task.h>
#include <stdio.h>
#include <stdlib.h>
#define TASK_PRIO 50
#define TASK_MODE AORI_RT_TASK_MODE_JOINABLE
#define TASK_STKSZ 0
AORI_RT_MUTEX mutex;
int shared_resource = 0;
void task_function(void *arg) {
int task_id = (int)(long)arg; // NOLINT
int ret;
printf("Task %d: Try to acquire mutex...\n", task_id);
ret = aori_mutex_acquire(&mutex, AORI_RT_TM_INFINITE);
if (ret) {
fprintf(stderr, "Task: aori_mutex_acquire %s\n", strerror(-ret));
return;
}
printf("Task %d: Successfully acquired the mutex\n", task_id);
// 访问共享资源
shared_resource++;
printf("Task %d: Increase the shared resource value to %d\n", task_id, shared_resource);
// 模拟工作
aori_task_sleep(1000000000); // 睡眠1秒
printf("Task %d: Release the mutex\n", task_id);
ret = aori_mutex_release(&mutex);
if (ret) {
fprintf(stderr, "Task: aori_mutex_release %s\n", strerror(-ret));
}
}
int main(int argc, char *argv[]) {
AORI_RT_TASK task1, task2;
int ret;
// 创建互斥锁
ret = aori_mutex_create(&mutex, "MyMutex");
if (ret) {
fprintf(stderr, "Task: aori_mutex_create %s\n", strerror(-ret));
return EXIT_FAILURE;
}
// 创建任务1
ret = aori_task_create(&task1, "Task1", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
return EXIT_FAILURE;
}
// 创建任务2
ret = aori_task_create(&task2, "Task2", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
return EXIT_FAILURE;
}
// 启动任务
aori_task_start(&task1, &task_function, (void *)1); // NOLINT
aori_task_start(&task2, &task_function, (void *)2); // NOLINT
// 等待任务完成
aori_task_join(&task1);
aori_task_join(&task2);
// 清理
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
aori_task_delete(&task2);
printf("Final shared resource value: %d\n", shared_resource);
return EXIT_SUCCESS;
}{{% /details %}}
aori_mutex_inquire
int aori_mutex_inquire (AORI_RT_MUTEX *mutex, RT_MUTEX_INFO *info);
查询互斥锁状态。
此例程返回指定互斥锁的状态信息。
参数
- mutex 互斥锁描述符。
- info 一个指向返回缓冲区的指针，用于复制信息。
返回值
成功时返回零，并将状态信息写入 info 指向的结构体。否则：
- 如果 mutex 不是有效的互斥锁描述符，则返回 -EINVAL。
- 如果此服务是从中断上下文调用的，则返回 -EPERM。
标签
xthread-only, switch-primary
{{% details title="示例代码" closed="true" %}}
c{filename="app.c"}
复制代码
#include <aori/rt/mutex.h>
#include <aori/rt/task.h>
#include <stdio.h>
#include <stdlib.h>
#define TASK_PRIO 50
#define TASK_MODE AORI_RT_TASK_MODE_JOINABLE
#define TASK_STKSZ 0
AORI_RT_MUTEX mutex;
int shared_resource = 0;
void task_function(void *arg) {
int task_id = (int)(long)arg; // NOLINT
int ret;
AORI_RT_MUTEX_INFO info;
printf("Task %d: Try to acquire mutex...\n", task_id);
ret = aori_mutex_inquire(&mutex, &info);
if (ret) {
fprintf(stderr, "Task: aori_mutex_inquire %s\n", strerror(-ret));
return;
}
printf("Task %d: Get mutex info\n", task_id);
printf("Task %d: Name :%s, Owner:%p\n", task_id, info.name, info.owner);
ret = aori_mutex_acquire(&mutex, AORI_RT_TM_INFINITE);
if (ret) {
fprintf(stderr, "Task: aori_mutex_acquire %s\n", strerror(-ret));
return;
}
printf("Task %d: Successfully acquired the mutex\n", task_id);
// 访问共享资源
shared_resource++;
printf("Task %d: Increase the shared resource value to %d\n", task_id, shared_resource);
// 模拟工作
aori_task_sleep(1000000000); // 睡眠1秒
printf("Task %d: Release the mutex\n", task_id);
ret = aori_mutex_release(&mutex);
if (ret) {
fprintf(stderr, "Task: aori_mutex_release %s\n", strerror(-ret));
}
}
int main(int argc, char *argv[]) {
AORI_RT_TASK task1, task2;
int ret;
// 创建互斥锁
ret = aori_mutex_create(&mutex, "MyMutex");
if (ret) {
fprintf(stderr, "Task: aori_mutex_create %s\n", strerror(-ret));
return EXIT_FAILURE;
}
// 创建任务1
ret = aori_task_create(&task1, "Task1", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
return EXIT_FAILURE;
}
// 创建任务2
ret = aori_task_create(&task2, "Task2", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
return EXIT_FAILURE;
}
// 启动任务
aori_task_start(&task1, &task_function, (void *)1); // NOLINT
aori_task_start(&task2, &task_function, (void *)2); // NOLINT
// 等待任务完成
aori_task_join(&task1);
aori_task_join(&task2);
// 清理
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
aori_task_delete(&task2);
printf("Final shared resource value: %d\n", shared_resource);
return EXIT_SUCCESS;
}{{% /details %}}
aori_mutex_release
int aori_mutex_release (AORI_RT_MUTEX *mutex);
释放/解锁互斥锁。
此例程释放先前通过调用 aori_mutex_acquire() 或 aori_mutex_acquire_until() 锁定的互斥锁对象。如果互斥锁处于挂起状态，则按优先级顺序立即解除第一个等待任务的阻塞，并将互斥锁的所有权转移给该任务；否则，互斥锁将处于未锁定状态。
参数
- mutex: 互斥锁描述符。
返回值
成功时返回零。否则：
- 如果 mutex 不是有效的互斥锁描述符，则返回 -EINVAL。
- 如果 mutex 不属于当前任务，或者更一般地说，如果此服务是在无法拥有任何互斥锁的上下文（例如中断上下文）中调用的，则返回 -EPERM。
标签
xthread-only, switch-primary
{{% details title="示例代码" closed="true" %}}
c{filename="app.c"}
复制代码
#include <aori/rt/mutex.h>
#include <aori/rt/task.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TASK_PRIO 50
#define TASK_MODE AORI_RT_TASK_MODE_JOINABLE
#define TASK_STKSZ 0
AORI_RT_MUTEX mutex;
int shared_resource = 0;
void task_function(void *arg) {
int task_id = (int)(long)arg; // NOLINT
int ret;
printf("Task %d: Try to acquire mutex...\n", task_id);
ret = aori_mutex_acquire(&mutex, AORI_RT_TM_INFINITE);
if (ret) {
fprintf(stderr, "Task: aori_mutex_acquire %s\n", strerror(-ret));
return;
}
printf("Task %d: Successfully acquired the mutex\n", task_id);
// 访问共享资源
shared_resource++;
printf("Task %d: Increase the shared resource value to %d\n", task_id, shared_resource);
// 模拟工作
aori_task_sleep(1000000000); // 睡眠1秒
printf("Task %d: Release the mutex\n", task_id);
ret = aori_mutex_release(&mutex);
if (ret) {
fprintf(stderr, "Task: aori_mutex_release %s\n", strerror(-ret));
}
}
int main(int argc, char *argv[]) {
AORI_RT_TASK task1, task2;
int ret;
// 创建互斥锁
ret = aori_mutex_create(&mutex, "MyMutex");
if (ret) {
fprintf(stderr, "Task: aori_mutex_create %s\n", strerror(-ret));
return EXIT_FAILURE;
}
// 创建任务1
ret = aori_task_create(&task1, "Task1", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
return EXIT_FAILURE;
}
// 创建任务2
ret = aori_task_create(&task2, "Task2", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
return EXIT_FAILURE;
}
// 启动任务
aori_task_start(&task1, &task_function, (void *)1); // NOLINT
aori_task_start(&task2, &task_function, (void *)2); // NOLINT
// 等待任务完成
aori_task_join(&task1);
aori_task_join(&task2);
// 清理
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
aori_task_delete(&task2);
printf("Final shared resource value: %d\n", shared_resource);
return EXIT_SUCCESS;
}{{% /details %}}
aori_mutex_unbind
int aori_mutex_unbind (AORI_RT_MUTEX *mutex);
解除互斥锁绑定。
参数
- mutex: 互斥锁描述符。
此例程释放先前对互斥锁的绑定。此调用返回后，描述符不再有效，无法用于引用该对象。
标签
mode-unrestricted, switch-secondary
{{% details title="示例代码" closed="true" %}}
c{filename="app.c"}
复制代码
#include <aori/rt/mutex.h>
#include <aori/rt/task.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TASK_PRIO 50
#define TASK_MODE AORI_RT_TASK_MODE_JOINABLE
#define TASK_STKSZ 0
AORI_RT_MUTEX mutex;
int shared_resource = 0;
void task_function(void *arg) {
int task_id = (int)(long)arg; // NOLINT
int ret;
AORI_RT_MUTEX mutex_task;
ret = aori_mutex_bind(&mutex_task, "MyMutex", AORI_RT_TM_INFINITE);
if (ret) {
fprintf(stderr, "Task: aori_mutex_bind %s\n", strerror(-ret));
return;
}
printf("Task %d: Try to acquire mutex...\n", task_id);
ret = aori_mutex_acquire(&mutex_task, AORI_RT_TM_INFINITE);
if (ret) {
fprintf(stderr, "Task: aori_mutex_acquire %s\n", strerror(-ret));
return;
}
printf("Task %d: Successfully acquired the mutex\n", task_id);
// 访问共享资源
shared_resource++;
printf("Task %d: Increase the shared resource value to %d\n", task_id, shared_resource);
// 模拟工作
aori_task_sleep(1000000000); // 睡眠1秒
printf("Task %d: Release the mutex\n", task_id);
ret = aori_mutex_release(&mutex_task);
if (ret) {
fprintf(stderr, "Task: aori_mutex_release %s\n", strerror(-ret));
}
aori_mutex_unbind(&mutex_task);
}
int main(int argc, char *argv[]) {
AORI_RT_TASK task1, task2;
int ret;
// 创建互斥锁
ret = aori_mutex_create(&mutex, "MyMutex");
if (ret) {
fprintf(stderr, "Task: aori_mutex_create %s\n", strerror(-ret));
return EXIT_FAILURE;
}
// 创建任务1
ret = aori_task_create(&task1, "Task1", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
return EXIT_FAILURE;
}
// 创建任务2
ret = aori_task_create(&task2, "Task2", TASK_STKSZ, TASK_PRIO, TASK_MODE);
if (ret) {
fprintf(stderr, "Task: aori_task_create %s\n", strerror(-ret));
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
return EXIT_FAILURE;
}
// 启动任务
aori_task_start(&task1, &task_function, (void *)1); // NOLINT
aori_task_start(&task2, &task_function, (void *)2); // NOLINT
// 等待任务完成
aori_task_join(&task1);
aori_task_join(&task2);
// 清理
aori_mutex_delete(&mutex);
aori_task_delete(&task1);
aori_task_delete(&task2);
printf("Final shared resource value: %d\n", shared_resource);
return EXIT_SUCCESS;
}{{% /details %}}
最近修改: 2026-03-02
- SP7010工智机如何使用本地I/O？
- SP7010PING不通且工智机扫描不到怎么解决
- 如何查询SX51系列工智机的串口波特率？
- SX21系列工智机如何更新Bios
- 工程任务执行超时后，如何安全删除该工程？
- 工智机跨设备工程报错"设备版本不匹配"如何解决？
- 工智机通过指令安装deb组件方法
- PC如何连接到工智机？
- 工智机远程文件传输
- 工智机系统时间不正确
- 不使用RTE如何检查硬件串口？
- Modbus运行样例
- MetaOS一级虚拟化系统如何安装软件？
- 工智机如何远程打开GUI程序
- MetaOS一级虚拟化系统默认开机启动浏览器
- MetaFacture扫描不到工智机如何处理？
- 如何添加RTE外部库?
- MetaOS一层虚拟化下如何安装Firefox浏览器？
- socat串口网口透传工具介绍
- SX5/58系列工智机启动共享文件夹
- 外界触摸屏下，工智机如何关闭三指触控？
- 在Windows主机上使用Socat
- SX5系列工智机无法访问网口配置问题
- SX2系列工智机常见网络问题处理方法
- MetaOS一级虚拟化，文件系统损坏如何修复？
- 如何登录及查看工智机系统
- 如何修改系统语言
- 如何用命令行方式设置网口IP
- 如何查看PLC状态
- 如何设置系统时间、硬件时间
- 如何查看系统资源状态
- 如何查看系统日志
- 如何系统CPU分配
- 如何系统网口分配
- 如何系统刷写及备份操作手册
- 如何设定系统内存
- 如何用命令行方式设置网卡中断
- ISO镜像文件制作
- EcatPortSet网口中断设置,禁用IPv4,IPv6,缓冲区设置
- 排查磁盘空间满了系统文件占用情况
- 如何禁用超线程
- 如何修改UOS桌面中IP地址
- 如何关闭Windows自检?
- 带桌面的Linux系统如何通过手机共享WIFI上网?
- win10系统sinsegye用户密码永久设置?
- USB设备直通虚拟机
- 串口调试工具无权限问题
- Windows分区异常如何修复?
- 浏览器密钥环问题
- 开机意外进入应急模式如何解决？
- Gpart格式化硬盘操作手册