Thread 类的start 方法如何判断线程的资源被空闲任务释放掉？

发布于 2020-12-14 15:00:34 浏览：1106 订阅该版

线程循环结束后立即调用rt_thread_exit,后由空闲任务释放资源，但是线程句柄指针是不为空的，怎么能更好的判断这个线程资源被释放了呢。
`
bool Thread::start()
{
    if(join(0) == RT_EOK)/* if thread is closed*/
    {
        _thread = rt_thread_create(_name,
                            (thread_func_t)func,
                            this,
                            _stack_size,
                            _priority,
                            _tick);  
    }
    /*if thread started then not start again*/
    if(started == false)
    {
        if (rt_thread_startup(_thread) == RT_EOK)
        {     
            started = true;
        }
    }
    return started;
}

rt_err_t Thread::join(int32_t millisec)
{
    if (started)
    {
        rt_int32_t tick;

if (millisec < 0)
            tick = -1;
        else
            tick = rt_tick_from_millisecond(millisec);
        
        rt_err_t ret = rt_event_recv(&_event, 1, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, tick, RT_NULL);
        if(ret == RT_EOK)
        {
            started = false;
            _thread = RT_NULL;//认为回收完毕
        }
        return ret;
    }
    else
    {
        return -RT_ENOSYS;
    }
}
`
在 join 的时候如果申请到 线程退出的事件 表示线程结束，但是不知道线程的资源有没有被释放完毕，强制对线程句柄置0，表示线程资源回收完毕，start 时进行创建
如何判断线程的资源被空闲任务释放掉？

1 个回答

传琦5858 2020-12-14

这家伙很懒，什么也没写！

问题应该算是解决了，因为线程退出时候 会设置为CLOSE , join 的时候 在指针释放前调用 rt_thread_idle_excute ，释放内存 这样就能确保没问题了
```
/*
 * Copyright (c) 2006-2018, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 */
#include "Thread.h"

using namespace rtthread;

Thread::Thread(rt_uint32_t stack_size,
               rt_uint8_t  priority,
               rt_uint32_t tick,
               const char *name)
    : _entry(RT_NULL), _param(RT_NULL), started(false),_stack_size(stack_size),_priority(priority),_tick(tick),_name(name)
{
    rt_event_init(&_event, name, 0);

_thread = rt_thread_create(name,
                               (thread_func_t)func,
                               this,
                               stack_size,
                               priority,
                               tick);
}

Thread::Thread(void (*entry)(void *p),
               void *p,
               rt_uint32_t stack_size,
               rt_uint8_t  priority,
               rt_uint32_t tick,
               const char *name)
    : _entry(entry), _param(p), started(false)
{
    rt_event_init(&_event, name, 0);

Thread::~Thread()
{
    rt_event_detach(&_event);
    rt_thread_delete(_thread);
}

bool Thread::start()
{
    /* if thread stop then create a new one */
    if(join(0) == RT_EOK)
    {
        _thread = rt_thread_create(_name,
                            (thread_func_t)func,
                            this,
                            _stack_size,
                            _priority,
                            _tick);  
    }
    /* if thread is stop then start */
    if(started == false)
    {
        if(rt_thread_startup(_thread) == RT_EOK)
        {     
            started = true;
        }
    }
    return started;
}

void Thread::sleep(int32_t millisec)
{
    rt_int32_t tick;

if (millisec < 0)
        tick = 1;
    else
        tick = rt_tick_from_millisecond(millisec);

rt_thread_delay(tick);
}

void Thread::func(Thread *pThis)
{
    if (pThis->_entry != RT_NULL)
    {
        pThis->_entry(pThis->_param);
    }
    else
    {
        pThis->run(pThis->_param);
    }
    /* thread end event send*/
    rt_event_send(&pThis->_event, 1);
}

void Thread::run(void *parameter)
{
    /* please overload this method */
}

rt_err_t Thread::wait(int32_t millisec)
{
    return join(millisec);
}

rt_err_t Thread::join(int32_t millisec)
{
    if (started)
    {
        rt_int32_t tick;

if (millisec < 0)
            tick = -1;
        else
            tick = rt_tick_from_millisecond(millisec);
        
        rt_err_t ret = rt_event_recv(&_event, 1, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, tick, RT_NULL);
        /* if thread is end */
        if(ret == RT_EOK)
        {
            /*run the idle excute to clean defunct thread*/
            rt_thread_idle_excute();
            
            /*set the thread handle null for next using*/
            _thread = RT_NULL;
            
            started = false;
        }
        return ret;
    }
    else
    {
        return -RT_ENOSYS;
    }
}

```