ThreadX 信号量

托马斯-木

于 2024-06-05 09:39:14 发布

阅读量989

点赞数 11

文章标签： Threadx RTOS

本文链接：https://blog.csdn.net/jingling122/article/details/139442797

版权

ThreadX 信号量（Semaphore）是一种用于同步线程或任务之间操作的机制。它允许一个或多个线程等待某个条件成立或某个资源可用，同时允许其他线程通知等待的线程条件已经成立或资源已经可用。ThreadX 信号量通常用于保护共享资源、限制对资源的并发访问数量、同步线程的执行顺序等场景。

信号量的基本概念

值：信号量有一个非负整数值，表示可用资源的数量或允许进入的线程数。
P 操作（等待/获取）：当一个线程想要访问受信号量保护的资源时，它会执行 P 操作（也称为等待或获取操作）。如果信号量的值大于 0，则将其减 1 并允许线程继续执行；如果信号量的值为 0，则线程将被阻塞，直到信号量的值变为非零。
V 操作（信号/释放）：当一个线程完成对受信号量保护的资源的访问时，它会执行 V 操作（也称为信号或释放操作）。这将使信号量的值加 1，并可能唤醒一个或多个正在等待该信号量的线程。

ThreadX 信号量的关键API函数

tx_semaphore_create
- 功能：创建一个新的信号量。
- 参数：包括指向信号量控制块的指针、信号量的名称和初始值。
- 返回值：成功时返回TX_SUCCESS，否则返回错误代码。
tx_semaphore_delete
- 功能：删除之前创建的信号量。
- 参数：指向要删除的信号量的指针。
- 返回值：成功时返回TX_SUCCESS，否则返回错误代码。
tx_semaphore_get
- 功能：获取（等待）信号量。
- 参数：包括指向信号量的指针和等待选项（如TX_WAIT_FOREVER表示无限期等待）。
- 返回值：成功时返回TX_SUCCESS，否则返回错误代码或TX_NOT_AVAILABLE（如果信号量不可用）。
tx_semaphore_put
- 功能：释放（信号）信号量。
- 参数：指向要释放的信号量的指针。
- 返回值：成功时返回TX_SUCCESS，否则返回错误代码。
tx_semaphore_put_notify
- 功能：释放信号量并通知等待的线程。
- 这个函数类似于tx_semaphore_put，但它在释放信号量后还会唤醒一个等待的线程（如果有的话）。

使用场景

保护共享资源：使用信号量可以确保同一时间只有一个线程访问共享资源，从而避免数据竞争和不一致。
限制并发访问：信号量可以用于限制对资源的并发访问数量，例如限制同时打开的文件数或网络连接数。
同步线程执行：通过信号量，可以同步多个线程的执行顺序，确保它们按照预定的顺序或依赖关系执行。

注意事项

在使用信号量时，要确保正确地执行 P 操作和 V 操作，以避免死锁或资源泄漏。
当多个线程等待同一个信号量时，它们的唤醒顺序是不确定的，除非使用了优先级调度或其他同步机制。
如果信号量的值被错误地设置为负数，可能会导致不可预测的行为。因此，在初始化信号量时要小心设置其初始值。

主要函数介绍

ThreadX 信号量相关函数主要用于在嵌入式系统中同步线程或任务之间的操作。以下是对ThreadX信号量相关函数的清晰介绍：

1. tx_semaphore_create

功能：

创建一个新的信号量。

函数原型：

UINT tx_semaphore_create( 
TX_SEMAPHORE *semaphore_ptr, 
CHAR *name_ptr, 
ULONG initial_count 
);

参数：

semaphore_ptr：指向信号量控制块的指针。
name_ptr：指向信号量名称的指针（用于调试和诊断）。
initial_count：信号量的初始值，通常在0到4,294,967,295之间。

返回值：

TX_SUCCESS (0x00)：成功创建信号量。
TX_SEMAPHORE_ERROR (0x0C)：无效的信号量指针。
TX_CALLER_ERROR (0x13)：无效的服务调用者。

2. tx_semaphore_delete

功能：

删除之前创建的信号量。

函数原型：

UINT tx_semaphore_delete(TX_SEMAPHORE *semaphore_ptr);

c复制代码

参数：

semaphore_ptr：指向要删除的信号量的指针。

返回值：

TX_SUCCESS (0x00)：成功删除信号量。
TX_SEMAPHORE_ERROR (0x0C)：无效的信号量指针。
TX_CALLER_ERROR (0x13)：无效的服务调用者。

3. tx_semaphore_get

功能：

获取（等待）信号量。

函数原型：

UINT tx_semaphore_get( 
TX_SEMAPHORE *semaphore_ptr, 
ULONG wait_option 
);

c复制代码

参数：

semaphore_ptr：指向要获取的信号量的指针。
wait_option：指定线程在信号量不可用时的等待选项。例如，TX_WAIT_FOREVER表示无限期等待。

返回值：

TX_SUCCESS (0x00)：成功获取信号量。
TX_NOT_AVAILABLE (0x0D)：信号量不可用。
TX_WAIT_ABORTED (0x1A)：等待被中止。

4. tx_semaphore_put

功能：

释放（信号）信号量。

函数原型：

UINT tx_semaphore_put(TX_SEMAPHORE *semaphore_ptr);

c复制代码

参数：

semaphore_ptr：指向要释放的信号量的指针。

返回值：

TX_SUCCESS (0x00)：成功释放信号量。
TX_SEMAPHORE_ERROR (0x0C)：无效的信号量指针。
TX_CALLER_ERROR (0x13)：无效的服务调用者。

注意事项：

在使用信号量时，务必注意正确地进行获取（get）和释放（put）操作，以避免死锁或资源泄漏。
信号量的初始值应根据实际需求来设置，以确保系统能够正确地同步线程或任务。
等待选项（wait_option）的设置应考虑到线程在等待信号量时的行为，例如是否允许中断、是否设置超时等。

例程

以下是一个简单的 ThreadX 信号量（Semaphore）的例程，用于展示如何在 ThreadX 系统中使用信号量来同步两个线程的执行。

首先，你需要有一个 ThreadX 环境设置好的项目。在这个例子中，我们假设你已经有一个 ThreadX 内核运行，并且已经创建了两个线程（Thread 1 和 Thread 2）。

1. 定义信号量

在全局范围内定义一个信号量，并为其分配一个控制块。

TX_SEMAPHORE my_semaphore;



/* 假设我们有一个全局的初始化函数，在这个函数中我们初始化信号量 */

void InitializeSemaphore(void)

{

/* 创建一个新的信号量，初始计数为 0 */

tx_semaphore_create(&my_semaphore, "My Semaphore", 0);

}



/* 这个函数应该在系统初始化时被调用 */

void SystemInitialize(void)

{

/* 初始化 ThreadX 内核和其他资源 */

/* ... */



/* 初始化信号量 */

InitializeSemaphore();



/* 启动线程 */

/* ... */

}

2. 线程 1 - 生产者

生产者线程会等待某个事件（例如数据准备好），然后释放信号量。

void thread_1_entry(ULONG thread_input)

{

/* 模拟数据准备过程 */

tx_thread_sleep(100); /* 假设需要 100 个时间片来准备数据 */



/* 数据准备好后，释放信号量 */

tx_semaphore_put(&my_semaphore);



/* 线程的其他工作... */



/* 线程结束或进入循环... */

}

3. 线程 2 - 消费者

消费者线程会等待信号量变为可用状态（即计数大于 0），然后执行某些操作（例如处理数据）。

void thread_2_entry(ULONG thread_input)

{

/* 等待信号量 */

tx_semaphore_get(&my_semaphore, TX_WAIT_FOREVER); /* 无限期等待 */



/* 信号量已经获取，处理数据 */

/* ... */



/* 线程的其他工作... */



/* 线程结束或进入循环... */

}

4. 线程创建

在主函数或初始化函数中，创建这两个线程。

void main(void)

{

/* 初始化硬件、操作系统等 */

SystemInitialize();



/* 创建线程 1（生产者） */

tx_thread_create(&thread_1, "Thread 1", thread_1_entry, 0,

pointer_to_stack_1, STACK_SIZE_1,

PRIORITY_1, TX_NO_TIME_SLICE, TX_AUTO_START);



/* 创建线程 2（消费者） */

tx_thread_create(&thread_2, "Thread 2", thread_2_entry, 0,

pointer_to_stack_2, STACK_SIZE_2,

PRIORITY_2, TX_NO_TIME_SLICE, TX_AUTO_START);



/* 启动 ThreadX 内核 */

tx_kernel_enter();

}

在这个例子中，线程 1（生产者）在模拟的数据准备过程后释放信号量，线程 2（消费者）在无限期等待后获取信号量并执行相应的操作。这样，线程 2 就不会在数据准备好之前执行处理操作，实现了线程间的同步。

请注意，你需要根据实际情况调整代码，例如线程栈的大小、优先级、等待选项等。此外，你还需要确保 ThreadX 内核和其他相关资源已经正确初始化。