Linux workqueue工作原理——简单介绍

傷城~ 2022-06-03 05:28 242阅读 0赞

http://blog.csdn.net/myarrow/article/details/8090504

**1. 什么是workqueue**  
       Linux中的Workqueue机制就是为了简化内核线程的创建。通过调用workqueue的接口就能创建内核线程。并且可以根据当前系统CPU的个数创建线程的数量，使得线程处理的事务能够并行化。workqueue是内核中实现简单而有效的机制，他显然简化了内核daemon的创建，方便了用户的编程.

工作队列（workqueue）是另外一种将工作推后执行的形式.工作队列可以把工作推后，交由一个内核线程去执行，也就是说，这个下半部分可以在进程上下文中执行。最重要的就是工作队列允许被重新调度甚至是睡眠。

**2. 数据结构**  
     我们把推后执行的任务叫做工作（work），描述它的数据结构为work\_struct:

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

1.  struct work\_struct \{  
2.      atomic\_long\_t data;       /\*工作处理函数func的参数\*/  
3.  \#define WORK\_STRUCT\_PENDING 0        /\* T if work item pending execution \*/  
4.  \#define WORK\_STRUCT\_STATIC 1        /\* static initializer (debugobjects) \*/  
5.  \#define WORK\_STRUCT\_FLAG\_MASK (3UL)  
6.  \#define WORK\_STRUCT\_WQ\_DATA\_MASK (~WORK\_STRUCT\_FLAG\_MASK)  
7.      struct list\_head entry;        /\*连接工作的指针\*/  
8.      work\_func\_t func;              /\*工作处理函数\*/  
9.  \#ifdef CONFIG\_LOCKDEP  
10.     struct lockdep\_map lockdep\_map;  
11. \#endif  
12. \};

这些工作以队列结构组织成工作队列（workqueue），其数据结构为workqueue\_struct:

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

1.  struct workqueue\_struct \{  
2.   struct cpu\_workqueue\_struct \*cpu\_wq;  
3.   struct list\_head list;  
4.   const char \*name;   /\*workqueue name\*/  
5.   int singlethread;   /\*是不是单线程 - 单线程我们首选第一个CPU -0表示采用默认的工作者线程event\*/  
6.   int freezeable;  /\* Freeze threads during suspend \*/  
7.   int rt;  
8.  \};

如果是多线程，Linux根据当前系统CPU的个数创建cpu\_workqueue\_struct 其结构体就是:

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

1.  truct cpu\_workqueue\_struct \{  
2.   spinlock\_t lock;/\*因为工作者线程需要频繁的处理连接到其上的工作，所以需要枷锁保护\*/  
3.   struct list\_head worklist;  
4.   wait\_queue\_head\_t more\_work;  
5.   struct work\_struct \*current\_work; /\*当前的work\*/  
6.   struct workqueue\_struct \*wq;   /\*所属的workqueue\*/  
7.   struct task\_struct \*thread; /\*任务的上下文\*/  
8.  \} \_\_\_\_cacheline\_aligned;

在该结构主要维护了一个任务队列，以及内核线程需要睡眠的等待队列，另外还维护了一个任务上下文，即task\_struct。  
       三者之间的关系如下：

![1350636977_5763.jpg][]

**3. 创建工作  
3.1 创建工作queue  
a. create\_singlethread\_workqueue(name)**  
        该函数的实现机制如下图所示，函数返回一个类型为struct workqueue\_struct的指针变量，该指针变量所指向的内存地址在函数内部调用kzalloc动态生成。所以driver在不再使用该work queue的情况下调用:

void destroy\_workqueue(struct workqueue\_struct \*wq)来释放此处的内存地址。

![1350637238_6853.jpg][]

图中的cwq是一per-CPU类型的地址空间。对于create\_singlethread\_workqueue而言，即使是对于多CPU系统，内核也只负责创建一个worker\_thread内核进程。该内核进程被创建之后，会先定义一个图中的wait节点，然后在一循环体中检查cwq中的worklist，如果该队列为空，那么就会把wait节点加入到cwq中的more\_work中，然后休眠在该等待队列中。

Driver调用queue\_work（struct workqueue\_struct \*wq, struct work\_struct \*work）向wq中加入工作节点。work会依次加在cwq->worklist所指向的链表中。queue\_work向cwq->worklist中加入一个work节点，同时会调用wake\_up来唤醒休眠在cwq->more\_work上的worker\_thread进程。wake\_up会先调用wait节点上的autoremove\_wake\_function函数，然后将wait节点从cwq->more\_work中移走。

worker\_thread再次被调度，开始处理cwq->worklist中的所有work节点...当所有work节点处理完毕，worker\_thread重新将wait节点加入到cwq->more\_work，然后再次休眠在该等待队列中直到Driver调用queue\_work...

**b. create\_workqueue**

![1350637427_9623.jpg][]

相对于create\_singlethread\_workqueue, create\_workqueue同样会分配一个wq的工作队列，但是不同之处在于，对于多CPU系统而言，对每一个CPU，都会为之创建一个per-CPU的cwq结构，对应每一个cwq，都会生成一个新的worker\_thread进程。但是当用queue\_work向cwq上提交work节点时，是哪个CPU调用该函数，那么便向该CPU对应的cwq上的worklist上增加work节点。

**c.小结**  
       当用户调用workqueue的初始化接口create\_workqueue或者create\_singlethread\_workqueue对workqueue队列进行初始化时，内核就开始为用户分配一个workqueue对象，并且将其链到一个全局的workqueue队列中。然后Linux根据当前CPU的情况，为workqueue对象分配与CPU个数相同的cpu\_workqueue\_struct对象，每个cpu\_workqueue\_struct对象都会存在一条任务队列。紧接着，Linux为每个cpu\_workqueue\_struct对象分配一个内核thread，即内核daemon去处理每个队列中的任务。至此，用户调用初始化接口将workqueue初始化完毕，返回workqueue的指针。

workqueue初始化完毕之后，将任务运行的上下文环境构建起来了，但是具体还没有可执行的任务，所以，需要定义具体的work\_struct对象。然后将work\_struct加入到任务队列中，Linux会唤醒daemon去处理任务。

上述描述的workqueue内核实现原理可以描述如下：

![1350637509_7795.jpg][]

**3.2  创建工作**  
       要使用工作队列，首先要做的是创建一些需要推后完成的工作。可以通过DECLARE\_WORK在编译时静态地建该结构：  
       DECLARE\_WORK(name,void (\*func) (void \*), void \*data);  
      这样就会静态地创建一个名为name，待执行函数为func，参数为data的work\_struct结构。  
      同样，也可以在运行时通过指针创建一个工作：  
      INIT\_WORK(structwork\_struct \*work, woid(\*func) (void \*), void \*data);

**4. 调度  
a. schedule\_work**

在大多数情况下, 并不需要自己建立工作队列，而是只定义工作, 将工作结构挂接到内核预定义的事件工作队列中调度, 在kernel/workqueue.c中定义了一个静态全局量的工作队列static struct workqueue\_struct \*keventd\_wq;默认的工作者线程叫做events/n，这里n是处理器的编号，每个处理器对应一个线程。比如，单处理器的系统只有events/0这样一个线程。而双处理器的系统就会多一个events/1线程。  
       调度工作结构, 将工作结构添加到全局的事件工作队列keventd\_wq，调用了queue\_work通用模块。对外屏蔽了keventd\_wq的接口，用户无需知道此参数，相当于使用了默认参数。keventd\_wq由内核自己维护，创建，销毁。这样work马上就会被调度，一旦其所在的处理器上的工作者线程被唤醒，它就会被执行。

**b. schedule\_delayed\_work(&work,delay);**  
      有时候并不希望工作马上就被执行，而是希望它经过一段延迟以后再执行。在这种情况下，同时也可以利用timer来进行延时调度，到期后才由默认的定时器回调函数进行工作注册。延迟delay后，被定时器唤醒，将work添加到工作队列wq中。

工作队列是没有优先级的，基本按照FIFO的方式进行处理。

** ****5. 示例**

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

1. \#include <linux/module.h>  
2. \#include <linux/init.h>  
3. \#include <linux/workqueue.h>  
4.   
5. static struct workqueue\_struct \*queue=NULL;  
6. static struct work\_struct   work;  
7.   
8. staticvoid work\_handler(struct work\_struct \*data)  
9. \{  
10.        printk(KERN\_ALERT"work handler function.\\n");  
11. \}  
12.   
13. static int \_\_init test\_init(void)  
14. \{  
15.       queue=create\_singlethread\_workqueue("hello world");/\*创建一个单线程的工作队列\*/  
16.       if (!queue)  
17.             goto err;  
18.   
19.        INIT\_WORK(&work,work\_handler);  
20.        schedule\_work(&work);  
21.   
22.       return0;  
23. err:  
24.       return\-1;  
25. \}  
26.   
27. static   void \_\_exit test\_exit(void)  
28. \{  
29.        destroy\_workqueue(queue);  
30. \}  
31. MODULE\_LICENSE("GPL");  
32. module\_init(test\_init);  
33. module\_exit(test\_exit);

<table> 
 <tbody> 
 <tr> 
 <td> 序号 </td> 
 <td> 接口函数 </td> 
 <td> 说明 </td> 
 </tr> 
 <tr> 
 <td> 1 </td> 
 <td> create_workqueue </td> 
 <td> 用于创建一个workqueue队列，为系统中的每个CPU都创建一个内核线程。输入参数： @name：workqueue的名称 </td> 
 </tr> 
 <tr> 
 <td> 2 </td> 
 <td> create_singlethread_workqueue </td> 
 <td> 用于创建workqueue，只创建一个内核线程。输入参数： @name：workqueue名称 </td> 
 </tr> 
 <tr> 
 <td> 3 </td> 
 <td> destroy_workqueue </td> 
 <td> 释放workqueue队列。输入参数： @ workqueue_struct：需要释放的workqueue队列指针 </td> 
 </tr> 
 <tr> 
 <td> 4 </td> 
 <td> schedule_work </td> 
 <td> 调度执行一个具体的任务，执行的任务将会被挂入Linux系统提供的workqueue——keventd_wq输入参数： @ work_struct：具体任务对象指针 </td> 
 </tr> 
 <tr> 
 <td> 5 </td> 
 <td> schedule_delayed_work </td> 
 <td> 延迟一定时间去执行一个具体的任务，功能与schedule_work类似，多了一个延迟时间，输入参数： @work_struct：具体任务对象指针 @delay：延迟时间 </td> 
 </tr> 
 <tr> 
 <td> 6 </td> 
 <td> queue_work </td> 
 <td> 调度执行一个指定workqueue中的任务。输入参数： @ workqueue_struct：指定的workqueue指针 @work_struct：具体任务对象指针 </td> 
 </tr> 
 <tr> 
 <td> 7 </td> 
 <td> queue_delayed_work </td> 
 <td> 延迟调度执行一个指定workqueue中的任务，功能与queue_work类似，输入参数多了一个delay。 </td> 
 </tr> 
 </tbody> 
</table>

转自：[http://bgutech.blog.163.com/blog/static/18261124320116181119889/][http_bgutech.blog.163.com_blog_static_18261124320116181119889]

[view plain]: http://blog.csdn.net/myarrow/article/details/8090504#
[1350636977_5763.jpg]: https://img-my.csdn.net/uploads/201210/19/1350636977_5763.jpg
[1350637238_6853.jpg]: https://img-my.csdn.net/uploads/201210/19/1350637238_6853.jpg
[1350637427_9623.jpg]: https://img-my.csdn.net/uploads/201210/19/1350637427_9623.jpg
[1350637509_7795.jpg]: https://img-my.csdn.net/uploads/201210/19/1350637509_7795.jpg
[http_bgutech.blog.163.com_blog_static_18261124320116181119889]: http://bgutech.blog.163.com/blog/static/18261124320116181119889/