信号量（semaphore）用来保护共享资源，临界区访问，同步；可以用于生产者-消费者模式中提供事件通知。
如果信号量计数器最大为1，其值可能为0或1，成为二进制信号量。二进制信号量作用类似互斥量，但信号量不支持所有权，不支持优先级继承。
信号量控制块
Threadx中信号量控制块(SCB)用来保持运行时(run-time)信号量状态的数据结构。
/* Define the semaphore structure utilized by the application. */
typedef struct TX_SEMAPHORE_STRUCT
{
/* Define the semaphore ID used for error checking. */
ULONG tx_semaphore_id;
/* Define the semaphore's name. */
CHAR_PTR tx_semaphore_name;
/* Define the actual semaphore count. A zero means that no semaphore
instance is available. */
ULONG tx_semaphore_count;
/* Define the semaphore suspension list head along with a count of
how many threads are suspended. */
struct TX_THREAD_STRUCT *tx_semaphore_suspension_list;
ULONG tx_semaphore_suspended_count;
/* Define the created list next and previous pointers. */
struct TX_SEMAPHORE_STRUCT
*tx_semaphore_created_next,
*tx_semaphore_created_previous;
TX_THREAD *sema_last_owner;
} TX_SEMAPHORE;
| 域 | 意义 |
|---|---|
| tx_semaphore_id | 信号量ID |
| tx_semaphore_name | 信号量名字指针 |
| tx_semaphore_count | 信号量计数器 |
| tx_semaphore_suspension_list | 信号量挂起队列 |
| tx_semaphore_suspended_count | 信号量挂起队列中元素个数 |
| tx_semaphore_created_next | 指向下一个信号量指针 |
| tx_semaphore_created_previous | 指向前一个信号量指针 |
| sema_last_owner | 最后一个获取信号量线程指针 |
信号量队列
系统中所有信号量控制块挂载一个双向链表_tx_semaphore_created_ptr中，tx_semaphore_created_next 指向下一个信号量指针，tx_semaphore_created_previous指向前一个信号量指针。
信号量API
| 函数 | 描述 |
|---|---|
| _tx_semaphore_create | 创建信号量 |
| _tx_semaphore_delete | 删除信号量 |
| _tx_semaphore_get | 申请信号量 |
| _tx_semaphore_info_get | 获取信号量信息 |
| _tx_semaphore_prioritize | 调整信号量挂起队列，使优先级最高线程在最前面 |
| _tx_semaphore_put | 释放信号量 |
优先级翻转
优先级翻转是指较低优先级已经获得信号量，这时较高优先级线程也需要获得的这个信号量时，较高优先级线程会被挂起，等待信号量释放。如果这时中等优先级任务抢占了低优先级任务，就出现了低优先级任务先执行，高优先级任务在等待，而且时间也变得不确定。
解决信号量导致的优先级翻转方法：开发人员通过合理设置优先级避免优先级翻转，或暂时提高拥有信号量的线程优先级避免优先级翻转。
互斥量支持优先级继承功能来提高拥有信号量的线程优先级。
信号量不支持优先级继承功能来提高拥有信号量的线程优先级。
信号量创建_tx_semaphore_create
_tx_semaphore_create用来创建信号量，入参为信号量指针，信号量名字指针，信号量计数器初值。
UINT _tx_semaphore_create(TX_SEMAPHORE *semaphore_ptr,
CHAR *name_ptr, ULONG initial_count)
{
TX_INTERRUPT_SAVE_AREA
TX_SEMAPHORE *tail_ptr; /* Working semaphore pointer */
/* Setup the basic semaphore fields. */
#def 设置初始化值
semaphore_ptr -> tx_semaphore_name = name_ptr;
semaphore_ptr -> tx_semaphore_count = initial_count;
semaphore_ptr -> tx_semaphore_suspension_list = TX_NULL;
semaphore_ptr -> tx_semaphore_suspended_count = 0;
/* Disable interrupts to place the semaphore on the created list. */
TX_DISABLE
/* Setup the semaphore ID to make it valid. */
semaphore_ptr -> tx_semaphore_id = TX_SEMAPHORE_ID;
/* Place the semaphore on the list of created semaphores. First,
check for an empty list. */
#def 插入_tx_semaphore_created_ptr list尾部
if (_tx_semaphore_created_ptr)
{
/* Pickup tail pointer. */
tail_ptr = _tx_semaphore_created_ptr -> tx_semaphore_created_previous;
/* Place the new semaphore in the list. */
_tx_semaphore_created_ptr -> tx_semaphore_created_previous = semaphore_ptr;
tail_ptr -> tx_semaphore_created_next = semaphore_ptr;
/* Setup this semaphore's next and previous created links. */
semaphore_ptr -> tx_semaphore_created_previous = tail_ptr;
semaphore_ptr -> tx_semaphore_created_next = _tx_semaphore_created_ptr;
}
else
{
/* The created semaphore list is empty. Add semaphore to empty list. */
_tx_semaphore_created_ptr = semaphore_ptr;
semaphore_ptr -> tx_semaphore_created_next = semaphore_ptr;
semaphore_ptr -> tx_semaphore_created_previous = semaphore_ptr;
}
/* Increment the number of semaphores created counter. */
_tx_semaphore_created_count++;
/* Restore interrupts. */
TX_RESTORE
/* Return TX_SUCCESS. */
return (TX_SUCCESS);
}
删除信号量_tx_semaphore_delete
删除信号量，如果tx_semaphore_suspension_list挂起队列中有线程，需要恢复线程
UINT _tx_semaphore_delete(TX_SEMAPHORE *semaphore_ptr)
{
TX_INTERRUPT_SAVE_AREA
TX_THREAD *thread_ptr; /* Working thread pointer */
/* Disable interrupts to remove the semaphore from the created list. */
TX_DISABLE
/* Decrement the number of semaphores created. */
_tx_semaphore_created_count--;
/* Clear the semaphore ID to make it invalid. */
semaphore_ptr -> tx_semaphore_id = 0;
#def 从_tx_semaphore_created_ptr 队列移除信号量
/* See if the semaphore is the only one on the list. */
if (semaphore_ptr == semaphore_ptr -> tx_semaphore_created_next)
{
/* Only created semaphore, just set the created list to NULL. */
_tx_semaphore_created_ptr = TX_NULL;
}
else
{
/* Link-up the neighbors. */
(semaphore_ptr -> tx_semaphore_created_next) -> tx_semaphore_created_previous =
semaphore_ptr -> tx_semaphore_created_previous;
(semaphore_ptr -> tx_semaphore_created_previous) -> tx_semaphore_created_next =
semaphore_ptr -> tx_semaphore_created_next;
/* See if we have to update the created list head pointer. */
if (_tx_semaphore_created_ptr == semaphore_ptr)
/* Yes, move the head pointer to the next link. */
_tx_semaphore_created_ptr = semaphore_ptr -> tx_semaphore_created_next;
}
/* Temporarily disable preemption. */
_tx_thread_preempt_disable++;
/* Restore interrupts. */
TX_RESTORE
/* Walk through the semaphore list to resume any and all threads suspended
on this semaphore. */
#def 删除tx_semaphore_suspension_list中所有线程，相应数据结构信息，并恢复线程
thread_ptr = semaphore_ptr -> tx_semaphore_suspension_list;
while (semaphore_ptr -> tx_semaphore_suspended_count)
{
/* Lockout interrupts. */
TX_DISABLE
/* Clear the cleanup pointer, this prevents the timeout from doing
anything. */
thread_ptr -> tx_suspend_cleanup = TX_NULL;
/* Temporarily disable preemption again. */
_tx_thread_preempt_disable++;
/* Restore interrupts. */
TX_RESTORE
#def 去激活定时器
/* Yes, deactivate the thread's timer just in case. */
_tx_timer_deactivate(&(thread_ptr -> tx_thread_timer));
/* Set the return status in the thread to TX_DELETED. */
thread_ptr -> tx_suspend_status = TX_DELETED;
/* Move the thread pointer ahead. */
thread_ptr = thread_ptr -> tx_suspended_next;
#def 恢复线程
/* Resume the thread. */
_tx_thread_resume(thread_ptr -> tx_suspended_previous);
/* Decrease the suspended count. */
semaphore_ptr -> tx_semaphore_suspended_count--;
}
/* Disable interrupts. */
TX_DISABLE
/* Release previous preempt disable. */
_tx_thread_preempt_disable--;
/* Restore interrupts. */
TX_RESTORE
#def 开中断（可以抢占了），有可能更高级线程需要执行，例如_tx_thread_resume会恢复高优先级线程，这里进行调度
/* Check for preemption. */
if (_tx_thread_current_ptr != _tx_thread_execute_ptr)
/* Transfer control to system. */
_tx_thread_system_return();
/* Return TX_SUCCESS. */
return (TX_SUCCESS);
}
