RT-Thread-RT-Thread 入门学习笔记：熟悉工作队列workqueue的使用RT-Thread问答社区

RT-Thread 入门学习笔记：熟悉工作队列workqueue的使用

发布于 2022-01-19 21:30:58 浏览：2442 订阅该版

[tocm]

[RT-Thread 入门学习笔记 - 目录](https://club.rt-thread.org/ask/article/3420.html)

## 前言

- 可以把一些运行优先级不高的操作放在工作队列workqueue的线程中执行

- 工作队列类似于消息队列，只是消息是个函数指针，多个操作可以排队的方式执行操作

- 初始化工作任务时可以指定延时的时间tick，这样会在指定时间超时后执行指定的任务

## 开启工作队列

- 这里使用RT-Thread ENV menuconfig：

![2022-01-19_211229.png](https://oss-club.rt-thread.org/uploads/20220119/afdf6d6f2c981ddd5cfef5ee1b0eb851.png)

- 可以修改工作队列【线程】的优先级与线程栈大小，一般优先级可以比其他的线程低，比IDLE线程高即可。

## 主要API

- `rt_work_init` ：用户的工作任务初始化，这里的工作任务是一个函数，注意是能执行完退出的。

- `rt_work_submit` : 通过submit，就把任务交给工作队列的线程，这个submit过程执行时间很短

- `rt_work_cancel` : 取消已经提交的工作任务，如果周期性的提交某个任务，可以先通过`rt_work_cancel`取消任务，再调用：`rt_work_submit`提交任务给工作队列线程。

## 操作示例

- 如有一个定时的操作，操作的时间比较久，如写文件，放在定时器中断中或软件定时器的线程中执行，可能会影响系统的定时器任务，这种情况下可以使用工作队列去执行耗时的操作。

- 在定时器超时回调函数里，把要执行的耗时操作任务，发给工作队列去执行，前提是这个耗时操作的执行优先级要求不苛刻。

```c
#include <rtthread.h>
#include <rtdevice.h>

#define DBG_ENABLE
#define DBG_SECTION_NAME    "workq.test"
#define DBG_LEVEL           DBG_LOG
#include <rtdbg.h>

#ifndef TEST_DUMP_TIME
#define TEST_DUMP_TIME          30
#endif

static struct rt_work test_work;

struct rt_timer test_timer  = { 0 };
static rt_bool_t test_timer_run_flag = RT_FALSE;
static rt_bool_t test_timer_init_flag = RT_FALSE;

/* work : do something with delay */
static void pm_log_to_file(struct rt_work *work, void *work_data)
{
    LOG_D("%s : log to file1,tick=%d", __func__, rt_tick_get());
    rt_thread_mdelay(20);
    LOG_D("%s : log to file2,tick=%d", __func__, rt_tick_get());
}

/* test timer timeout entry */
static void test_timer_timeout(void *param)
{
    rt_work_cancel(&test_work);
    rt_work_submit(&test_work, 0);
}

/* test timer init */
rt_err_t test_timer_init(void)
{
    rt_work_init(&test_work, pm_log_to_file, RT_NULL);

if (test_timer_init_flag == RT_TRUE)
    {
        return -RT_ERROR;
    }

rt_timer_init(&test_timer, "test_tm", test_timer_timeout, RT_NULL,
        (TEST_DUMP_TIME * RT_TICK_PER_SECOND), RT_TIMER_FLAG_PERIODIC | RT_TIMER_FLAG_SOFT_TIMER);

test_timer_init_flag = RT_TRUE;

return RT_TRUE;
}

/* test timer Start */
rt_err_t test_timer_start(void)
{
    rt_err_t ret = RT_EOK;

if (test_timer_init_flag == RT_FALSE)
    {
        return -RT_ERROR;
    }

if (test_timer_run_flag == RT_FALSE)
    {
        ret = rt_timer_start(&test_timer);
    }

if (ret == RT_EOK)
    {
        test_timer_run_flag = RT_TRUE;
    }

return ret;
}

/* test timer Stop*/
rt_err_t test_timer_stop(void)
{
    rt_err_t ret = RT_EOK;

if (test_timer_init_flag == RT_FALSE)
    {
        return -RT_ERROR;
    }

if (test_timer_run_flag == RT_TRUE)
    {
        ret = rt_timer_stop(&test_timer);
    }

if (ret == RT_EOK)
    {
        test_timer_run_flag = RT_FALSE;
    }

return ret;
}

void test_work_start(void)
{
    test_timer_init();
    test_timer_start();
}

void test_work_stop(void)
{
    test_timer_stop();
}

MSH_CMD_EXPORT(test_timer_init, test_timer_init);
MSH_CMD_EXPORT(test_timer_start, test_timer_start);
MSH_CMD_EXPORT(test_timer_stop, test_timer_stop);

MSH_CMD_EXPORT(test_work_start, test_work_start);
MSH_CMD_EXPORT(test_work_stop, test_work_stop);
```

## 编译与运行

- 注意工作队列的依赖：`RT_USING_HEAP`，也就是需要开启动态内存管理

- 验证平台：STM32L475 pandora开发板

- MSH cmd命令：`list_thread`查看工作队列开启情况

```c
msh >list_thread
thread   pri  status      sp     stack size max used left tick  error
-------- ---  ------- ---------- ----------  ------  ---------- ---
tshell    20  running 0x0000008c 0x00001000    12%   0x0000000a 000
sys_work  23  suspend 0x00000060 0x00000800    04%   0x0000000a 000  /* 工作队列线程 */
tidle0    31  ready   0x00000048 0x00000100    40%   0x0000001b 000
main      10  suspend 0x00000084 0x00000800    13%   0x00000013 000
msh >
```

- 任务开启，例程里30秒超时中断里，把耗时的操作提交给工作队列去执行

```c
msh >test_work_start                     /* 开启任务 */
msh >list_thread                         /* 查看线程 */
thread   pri  status      sp     stack size max used left tick  error
-------- ---  ------- ---------- ----------  ------  ---------- ---
tshell    20  running 0x0000008c 0x00001000    12%   0x00000002 000
sys_work  23  suspend 0x00000060 0x00000800    04%   0x0000000a 000
tidle0    31  ready   0x00000048 0x00000100    40%   0x00000006 000
main      10  suspend 0x00000084 0x00000800    13%   0x00000013 000

msh >list_timer                        /* 查看定时器 */
timer     periodic   timeout    activated     mode
-------- ---------- ---------- ----------- ---------
test_tm  0x00007530 0x0011f461 activated   periodic
tshell   0x00000000 0x00000000 deactivated one shot
sys_work 0x00000000 0x00000000 deactivated one shot
tidle0   0x00000000 0x00000000 deactivated one shot
main     0x000001f4 0x0011b91d activated   one shot
current tick:0x0011b8a8
msh >[D/workq.test] pm_log_to_file : log to file1,tick=1176674
[D/workq.test] pm_log_to_file : log to file2,tick=1176699
[D/workq.test] pm_log_to_file : log to file1,tick=1206674
[D/workq.test] pm_log_to_file : log to file2,tick=1206699
[D/workq.test] pm_log_to_file : log to file1,tick=1236674
[D/workq.test] pm_log_to_file : log to file2,tick=1236699
```

- 通过LOG显示，定时的操作在工作队列执行正常

## 小结

- 为何使用工作队列？自己新建一个线程不就行了吗？新建一个线程当然是可以的，使用工作队列，多个任务都可以提交，并且节省资源，操作也很简单

- 工作队列是任务排队执行，所以任务中不能有死循环:while (1)，否则会阻塞其他任务的执行

- 一些对时间或时序要求苛刻的操作，还是新建一个线程执行会更可靠。