Threadx 互斥量mutex

文章目录

- 互斥量控制块
- 互斥量队列
- 互斥量API
- 互斥量创建_tx_mutex_create
- 删除互斥量 _tx_semaphore_delete

互斥量用来保证对共享资源或临界区的访问唯一性，保证在指定范围内，只能有一个线程访问该共享资源。
Threadx中同一个线程可以多次申请同一互斥量，并且释放互斥量必须释放相同次数。

互斥量控制块

Threadx中互斥量控制块(MCB)是用来保持运行时互斥量状态的数据结构。

/* Define the mutex structure utilized by the application.  */

typedef struct TX_MUTEX_STRUCT
{

    /* Define the mutex ID used for error checking.  */
    ULONG       tx_mutex_id;

    /* Define the mutex's name.  */
    CHAR_PTR    tx_mutex_name;

    /* Define the mutex ownership count.  */
    ULONG       tx_mutex_ownership_count;

    /* Define the mutex ownership pointer.  This pointer points to the
       the thread that owns the mutex.  */
    TX_THREAD   *tx_mutex_owner;

    /* Define the priority inheritance flag.  If this flag is set, priority
       inheritance will be in effect.  */
    UINT        tx_mutex_inherit;

    /* Define the save area for the owning thread's original priority and
       threshold.  */
    UINT        tx_mutex_original_priority;
    UINT        tx_mutex_original_threshold;

    /* Define the mutex suspension list head along with a count of
       how many threads are suspended.  */
    struct TX_THREAD_STRUCT  *tx_mutex_suspension_list;
    ULONG                    tx_mutex_suspended_count;

    /* Define the created list next and previous pointers.  */
    struct TX_MUTEX_STRUCT
        *tx_mutex_created_next,
        *tx_mutex_created_previous;

} TX_MUTEX;

域	意义
tx_mutex_id	互斥量控制块ID
tx_mutex_name	互斥量名字指针
tx_mutex_ownership_count	互斥量所有权计数器，表示某线程获取互斥量次数,范围0到2^32-1
tx_mutex_owner	拥有互斥量的线程指针
tx_mutex_inherit	优先级继承标志
tx_mutex_original_priority	拥有互斥量的线程的原始优先级
tx_mutex_original_threshold	拥有互斥量的线程的原始抢占门限
tx_mutex_suspension_list	互斥量挂起list指针
tx_mutex_suspended_count	互斥量挂起list上线程个数
tx_mutex_created_next	指向下一个互斥量指针
tx_mutex_created_previous	指向前一个互斥量指针

互斥量队列

系统中所有互斥量挂载同一个链表中，_tx_mutex_created_ptr执行链表头部。tx_mutex_created_next 指向下一个互斥量，tx_mutex_created_previous 指向前一个互斥量。

TX_MUTEX    *_tx_mutex_created_ptr;

在这里插入图片描述

互斥量API

函数	描述
UINT _tx_mutex_create(TX_MUTEX mutex_ptr, CHAR name_ptr, UINT inherit)	创建互斥量
UINT _tx_mutex_delete(TX_MUTEX *mutex_ptr)	删除互斥量
UINT _tx_mutex_get(TX_MUTEX *mutex_ptr, ULONG wait_option)	申请互斥量
UINT _tx_mutex_info_get(TX_MUTEX mutex_ptr, CHAR name, ULONG count, TX_THREAD owner,TX_THREAD first_suspended, ULONG suspended_count,TX_MUTEX *next_mutex	获取互斥量信息
UINT _tx_mutex_prioritize(TX_MUTEX *mutex_ptr)	调整最高优先级线程到互斥量挂起队列的最前面
UINT _tx_mutex_put(TX_MUTEX *mutex_ptr)	释放拥有的互斥量
VOID _tx_mutex_priority_change(TX_THREAD *thread_ptr, UINT new_priority, UINT new_threshold)	改变线程优先级和抢占门限
VOID _tx_mutex_cleanup(TX_THREAD *thread_ptr)	clean线程在互斥量数据结构

mutex_create_83">互斥量创建_tx_mutex_create

_tx_mutex_create创建互斥量，函数很简单。同一资源的互斥量只创建一次，互斥量创建时并没有拥有者。
线程使用时需要申请。

UINT    _tx_mutex_create(TX_MUTEX *mutex_ptr, CHAR *name_ptr, UINT inherit)
{

    TX_INTERRUPT_SAVE_AREA

    TX_MUTEX   *tail_ptr;                   /* Working mutex pointer  */


    /* Setup the basic mutex fields.  */
    mutex_ptr -> tx_mutex_name =             name_ptr;
    mutex_ptr -> tx_mutex_ownership_count =  0;
    #def 优先级继承标志
    mutex_ptr -> tx_mutex_inherit =          inherit;
    mutex_ptr -> tx_mutex_suspension_list =  TX_NULL;
    mutex_ptr -> tx_mutex_suspended_count =  0;

    /* Disable interrupts to place the mutex on the created list.  */
    TX_DISABLE

    /* Setup the mutex ID to make it valid.  */
    mutex_ptr -> tx_mutex_id =  TX_MUTEX_ID;

    /* Place the mutex on the list of created mutexes.  First,
       check for an empty list.  */
    #def 把互斥量插入_tx_mutex_created_ptr 队列
    if (_tx_mutex_created_ptr)
    {

        /* Pickup tail pointer.  */
        tail_ptr =  _tx_mutex_created_ptr -> tx_mutex_created_previous;

        /* Place the new mutex in the list.  */
        _tx_mutex_created_ptr -> tx_mutex_created_previous =  mutex_ptr;
        tail_ptr -> tx_mutex_created_next =                   mutex_ptr;

        /* Setup this mutex's next and previous created links.  */
        mutex_ptr -> tx_mutex_created_previous =  tail_ptr;
        mutex_ptr -> tx_mutex_created_next =      _tx_mutex_created_ptr;
    }
    else
    {

        /* The created mutex list is empty.  Add mutex to empty list.  */
        _tx_mutex_created_ptr =                   mutex_ptr;
        mutex_ptr -> tx_mutex_created_next =      mutex_ptr;
        mutex_ptr -> tx_mutex_created_previous =  mutex_ptr;
    }

    /* Increment the number of mutexes created counter.  */
    _tx_mutex_created_count++;

    /* Restore interrupts.  */
    TX_RESTORE

    /* Return TX_SUCCESS.  */
    return (TX_SUCCESS);
}

删除互斥量 _tx_semaphore_delete

删除互斥量：
1，把互斥量从_tx_mutex_created_ptr 队列删除。
2，把tx_mutex_suspension_list队列中线程移除，清除互斥量数据结构，并恢复线程

UINT    _tx_mutex_delete(TX_MUTEX *mutex_ptr)
{

    TX_INTERRUPT_SAVE_AREA

    TX_THREAD       *thread_ptr;                /* Working thread pointer  */


    /* Disable interrupts to remove the mutex from the created list.  */
    TX_DISABLE

    /* Decrement the number of mutexes created.  */
    _tx_mutex_created_count--;

    /* Clear the mutex ID to make it invalid.  */
    mutex_ptr -> tx_mutex_id =  0;

    /* See if the mutex is the only one on the list.  */
    #def 从_tx_mutex_created_ptr 删除mutex
    if (mutex_ptr == mutex_ptr -> tx_mutex_created_next)
    {

        /* Only created mutex, just set the created list to NULL.  */
        _tx_mutex_created_ptr =  TX_NULL;
    }
    else
    {

        /* Link-up the neighbors.  */
        (mutex_ptr -> tx_mutex_created_next) -> tx_mutex_created_previous =
            mutex_ptr -> tx_mutex_created_previous;
        (mutex_ptr -> tx_mutex_created_previous) -> tx_mutex_created_next =
            mutex_ptr -> tx_mutex_created_next;

        /* See if we have to update the created list head pointer.  */
        if (_tx_mutex_created_ptr == mutex_ptr)

            /* Yes, move the head pointer to the next link. */
            _tx_mutex_created_ptr =  mutex_ptr -> tx_mutex_created_next;
    }

    /* Temporarily disable preemption.  */
    _tx_thread_preempt_disable++;

    /* Restore interrupts.  */
    TX_RESTORE

    /* Walk through the mutex list to resume any and all threads suspended
       on this mutex.  */
    thread_ptr =  mutex_ptr -> tx_mutex_suspension_list;
    #def 从tx_mutex_suspension_list移除线程，清除数据，并恢复线程
    while (mutex_ptr -> tx_mutex_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

        /* 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;

        /* Resume the thread.  */
        _tx_thread_resume(thread_ptr -> tx_suspended_previous);

        /* Decrease the suspended count.  */
        mutex_ptr -> tx_mutex_suspended_count--;
    }

    /* Disable interrupts.  */
    TX_DISABLE

    /* Release previous preempt disable.  */
    _tx_thread_preempt_disable--;

    /* Restore interrupts.  */
    TX_RESTORE

    /* 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);
}