workqueue --最清晰的讲解【转】

深碍√TFBOYSˉ_ 2021-12-22 01:15 324阅读 0赞

转自：[https://www.cnblogs.com/zxc2man/p/6604290.html][https_www.cnblogs.com_zxc2man_p_6604290.html]

带你入门：

1.INIT\_WORK(struct work\_struct \*work, void (\*function)(void \*), void \*data) 上面一句只是定义了work和work对应的操作。  要是在实际使用的时候还是需要你去在适当的条件下激活这个work。只有激活了这个work，  这个work才有运行的机会。这个激活操作接口是shudule\_work或是queue\_work。  这两个接口之后只是说这个work有了运行的机会，但是具体到什么时候运行，那要看你用哪个接口激活

的。  如果是shudule\_work的话，系统中有个events内核线程，这个线程会处理你用shudule\_work接口激活  的所有work。如果是queue\_work的话，一般这种情况都是自己创建了一个单独的处理线程，这样将  你激活的work和这个线程联系起来。至于什么时候运行，那就是events或是你定义的特定线程运行的时

候。

2.至于你提到的为什么要用到work。这个的话，我个人的理解是：一般用在对耗时处理上。比如，  当中断发生的时候，你可以在中断上下文中完成激活操作，让那些耗时的操作在work中完成。

系统化讲解：

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

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

**2. 数据结构 **我们把推后执行的任务叫做工作（work），描述它的数据结构为work\_struct， struct work\_struct \{     atomic\_long\_t data;       /\*工作处理函数func的参数\*/ \#define WORK\_STRUCT\_PENDING 0        /\* T if work item pending execution \*/ \#define WORK\_STRUCT\_STATIC 1        /\* static initializer (debugobjects) \*/ \#define WORK\_STRUCT\_FLAG\_MASK (3UL) \#define WORK\_STRUCT\_WQ\_DATA\_MASK (~WORK\_STRUCT\_FLAG\_MASK)     struct list\_head entry;        /\*连接工作的指针\*/     work\_func\_t func;              /\*工作处理函数\*/ \#ifdef CONFIG\_LOCKDEP     struct lockdep\_map lockdep\_map; \#endif \};

这些工作以队列结构组织成工作队列（workqueue），其数据结构为workqueue\_struct， struct workqueue\_struct \{  struct cpu\_workqueue\_struct \*cpu\_wq;  struct list\_head list;  const char \*name;   /\*workqueue name\*/  int singlethread;   /\*是不是单线程 - 单线程我们首选第一个CPU -0表示采用默认的工作者线程event\*/  int freezeable;  /\* Freeze threads during suspend \*/  int rt; \};

如果是多线程，Linux根据当前系统CPU的个数创建cpu\_workqueue\_struct 其结构体就是， truct cpu\_workqueue\_struct \{  spinlock\_t lock;/\*因为工作者线程需要频繁的处理连接到其上的工作，所以需要枷锁保护\*/  struct list\_head worklist;  wait\_queue\_head\_t more\_work;  struct work\_struct \*current\_work; /\*当前的work\*/  struct workqueue\_struct \*wq;   /\*所属的workqueue\*/  struct task\_struct \*thread; /\*任务的上下文\*/ \} \_\_\_\_cacheline\_aligned; 在在该结构主要维护了一个任务队列，以及内核线程需要睡眠的等待队列，另外还维护了一个任务上下文，即task\_struct。 三者之间的关系如下：

![workqueue - G-tech - G-tech的博客][workqueue - G-tech - G-tech]

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

![workqueue - G-tech - G-tech的博客][workqueue - G-tech - G-tech 1]

图中的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

![workqueue - G-tech - G-tech的博客][workqueue - G-tech - G-tech 2]

相对于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内核实现原理可以描述如下：

![workqueue - G-tech - G-tech的博客][workqueue - G-tech - G-tech 3]

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. 示例： **\#include <linux/module.h> \#include <linux/init.h> \#include <linux/workqueue.h>

static struct workqueue\_struct \*queue=NULL; static struct work\_struct   work;

staticvoid work\_handler(struct work\_struct \*data) \{        printk(KERN\_ALERT"work handler function.\\n"); \}

static int \_\_init test\_init(void) \{       queue=create\_singlethread\_workqueue("hello world");/\*创建一个单线程的工作队列\*/       if (!queue)             goto err;

INIT\_WORK(&work,work\_handler);        schedule\_work(&work);

return0; err:       return-1; \}

static   void \_\_exit test\_exit(void) \{        destroy\_workqueue(queue); \} MODULE\_LICENSE("GPL"); module\_init(test\_init); module\_exit(test\_exit);

=======================================================================

分成两大部分，第一部分是用来执行work queue中每个节点上挂载的函数的**内核线程**，第二部分是从驱动程序的角度看**work queue的使用**。  
  
第一部分 worker\_thread内核线程  
Linux系统启动期间会创建一名为worker\_thread线程，该线程创建之后就处于sleep状态。这里所谓的内核线程，从调度器的角度就是一可 以调度的进程，从代码的表现形式看，就是一函数。系统创建的这个worker\_thread线程基于一workqueue\_struct结构变量上（该结 构体变量的成员name为"events"）.  
  
第二部分 work queue的使用  
1.只考虑使用系统的keventd管理的工作队列  
驱动程序调用schedule\_work向工作队列递交新的工作节点，schedule\_work内部会唤醒worker\_thread内核线程（使之进 程状态为可调度）。在下一次进程调度时刻，worker\_thread被调度执行，其主要任务便是调用它所管理工作队列中每个工作节点上挂载的函数，调用 完毕该工作节点会从任务队列中被删除。当所有节点上的函数调用完毕，worker\_thread继续sleep，直到schedule\_work再次被某 个驱动程序调用。  
与使用驱动程序自己创建的工作对列的区别是：schedule\_work内部是调用**queue\_work(keventd\_wq, work)**，而使用驱动程序自己创建的工作队列在调用queue\_work时的第一个参数是驱动程序自己创建的工作队列。  
  
2.驱动程序使用自己创建的工作队列  
这种情况驱动程序调用create\_workqueue。该函数的原理跟1中基本是一样的，只不过再会创建一个内核进程，该内核进程的内核函数名字依然为worker\_thread，只不过这个worker\_thread工作在新的属于驱动程序自己的工作队列。  
使用方法是：  
a. 调用create\_workqueue生成属于驱动程序自己的work queue. struct workqueue\_struct \*my\_workqueue = create\_workqueue("my\_workqueue");  
b.调用queue\_work象a中生成的my\_workqueue中注册工作节点， **queue\_work(my\_workqueue, work)**  
  
这两种情况下的内核线程其实都是利用了一个名为kthreadd的内核线程来创建工作队列的worker\_thread，其本质是向全局列表 kthread\_create\_list中加入相应的内核线程函数节点，由kthreadd来负责创建进程框架，然后运行 kthread\_create\_list中加入的节点上的内核线程函数。  
向kthread\_create\_list中每加入一个内核线程函数节点，都会唤醒kthreadd线程。  
  
当等待队列是空时，worker\_thread会睡眠在该等待队列中。当driver调用queue\_work时，再向等待队列中加入工作节点的同时，会唤醒睡眠在该等待队列上的worker\_thread线程。  
关于worker\_thread内核线程的创立过程：  
最开始由void \_\_init **init\_workqueues**(void)发起(Workqueue.c)，依次的关键调用节点分别是（为了便于叙述，在内核代码基础上略有改动，但不影响核心调用过程）  
  
create\_workqueue("events");  
\_\_create\_workqueue((("events"), 0, 0);  
\_\_create\_workqueue\_key("events", 0, 0, NULL, NULL);  
  
在\_\_create\_workqueue\_key("events", 0, 0, NULL, NULL)中：  
1).首先创建一个struct workqueue\_struct指针型变量\*wq, wq->name = "events".这个新建的队列指针将被记录在全局变量keventd\_wq中.  
    workqueue\_struct定义如下：  
   **struct workqueue\_struct \{  
        struct cpu\_workqueue\_struct \*cpu\_wq;  
        struct list\_head list;  
        const char \*name;  
        int singlethread;  
        int freezeable;                /\* Freeze threads during suspend \*/  
\#ifdef CONFIG\_LOCKDEP  
        struct lockdep\_map lockdep\_map;  
\#endif  
\};**  
2).把wq所在的队列节点加入到一名为workqueues的全局变量中(list\_add(&wq->list, &workqueues)).  
3).调用create\_workqueue\_thread()，最终调用kthread\_create(worker\_thread, cwq, fmt, wq->name, cpu)来生成内核线程worker\_thread.  
Linux内核中最终是通过do\_fork来生成内核线程(正如前面所说，这其实是个能被调度的进程，拥有自己的task\_struct结构)，这个过程 在内核中是个比较复杂的过程，比较重要的节点总结如下：在当前进程下调用do\_fork来生成一个新进程时，会大量copy当前进程的 task\_struct结构到新进程的task\_struct变量中，新进程如果被调度运行，入口点（pc值）是 kernel\_thread\_helper函数，在该函数中会再次将pc值设置为kernel\_thread（）中的function指针，也就是在调用 kernel\_thread函数时第一参数所表示的函数。  
  
所以,在Linux系统初始化期间，会生成一个新进程，该进程的执行线程/函数为worker\_thread，该进程被创建出来之后的状态是STOP，这 意味着该线程无法进入调度队列直到针对该进程调用wake\_up\_process（）,该进程才会真正进入调度队列，如果被调度，则开始运行 worker\_thread函数。新进程被赋予的调度优先级为KTHREAD\_NICE\_LEVEL(-5)，这个标志的实际含义将在Linux进程调度 的帖子里去写。然后对于worker\_thread线程函数本身，会进一步调整调度优先级(set\_user\_nice(current,  -5))，这样worker\_thread所在进程的优先值将为-10,在可抢占式的Linux内核中，如此高的调度优先级极易导致一个调度时点，即使当 前进程也许正运行在内核态，也可能被切换出CPU，代之以worker\_thread.  
在kernel\_thread\_helper函数中，在调用内核线程函数之前设定返回地址为do\_exit()函数，所以当内核线程函数退出的话将导致该进程的消失。  
比如ARM中的kernel\_thread\_helper函数代码：  
**extern void kernel\_thread\_helper(void);  
asm(        ".section .text\\n"  
"        .align\\n"  
"        .type        kernel\_thread\_helper, \#function\\n"  
"kernel\_thread\_helper:\\n"  
"        mov        r0, r1\\n"  
"        mov        lr, r3\\n"  
"        mov        pc, r2\\n"  
"        .size        kernel\_thread\_helper, . - kernel\_thread\_helper\\n"  
"        .previous");**  
  
mov lr, r3设定内核线程函数返回后的返回地址，Linux内核代码设定为do\_exit().  
  
可以想象，象worker\_thread这种内核线程函数，一般不会轻易退出，除非对内核线程函数所在的进程上调用kthread\_stop函数。  
上述的kernel\_thread\_helper函数中的mov pc, r2将会导致worker\_thread（）函数被调用，该函数定义如下：  
**static int worker\_thread(void \*\_\_cwq)  
\{  
        struct cpu\_workqueue\_struct \*cwq = \_\_cwq;  
        DEFINE\_WAIT(wait);  
  
        if (cwq->wq->freezeable)  
                set\_freezable();  
  
        set\_user\_nice(current, -5);  
  
        for (;;) \{  
                prepare\_to\_wait(&cwq->more\_work, &wait, TASK\_INTERRUPTIBLE);  
                if (!freezing(current) &&  
                    !kthread\_should\_stop() &&  
                    list\_empty(&cwq->worklist))  
                        schedule();  
                finish\_wait(&cwq->more\_work, &wait);  
  
                try\_to\_freeze();  
  
                if (kthread\_should\_stop())  
                        break;  
  
                run\_workqueue(cwq);  
        \}  
\}**  
正如前面猜测的那样，该函数不会轻易退出，其核心是一for循环，如果任务队列中有新的节点，则执行该节点上的函数（在run\_workqueue()内部），否则worker\_thread所在的进程将会继续休眠。  
  
对work  queue的深入理解需要了解Linux的调度机制，最基本的是Linux内核的调度时机，因为这关系到驱动程序开发者能对自己注册到任务队列函数的执行 时机有大体的了解。在2.4内核中，除了进程主动调用schedule()这种主动的调度方式外，调度发生在由内核态向用户态转变（从中断和系统调用返 回）的时刻，因为内核不可抢占性，所以内核态到内核态的转变时调度不会发生。而在2.6内核中，因为内核可抢占已经被支持，这意味着调度的时机除了发生在 内核态向用户态转变时，运行在内核态的进程也完全有可能被调度出处理器，比如当前进程重新允许抢占（调用preempt\_enable()）。在内核态的 进程允许被抢占，意味着对高优先级进程的调度粒度更细：如果当前进程允许被抢占，那么一旦当前调度队列中有比当前进程优先级更高的进程，当前进程将被切换 出处理器（最常见的情况是在系统调用的代码中接收到中断，当中断返回时，2.4代码会继续运行被中断的系统调用，而2.6代码的可抢占性会导致一个调度时 点，原先被中断的系统调用所在的进程可能会被调度队列中更高优先级的进程所取代）。关于进程的调度，会在另外的帖子中详细介绍。  
  
**create\_singlethread\_workqueue(name)与create\_workqueue(name)**  
Driver调用这两个宏来创建自己的工作队列以及相应的内核进程（其内核线程函数为worker\_thread，下来为了方便叙述，就简称该进程为worker\_thread进程)  
1. create\_singlethread\_workqueue(name)  
该函数的实现机制如下图所示，函数返回一个类型为struct  workqueue\_struct的指针变量，该指针变量所指向的内存地址在函数内部调用kzalloc动态生成。所以driver在不再使用该work queue的情况下调用void destroy\_workqueue(struct workqueue\_struct  \*wq)来释放此处的内存地址。  
  
图中的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...

转载于:https://www.cnblogs.com/sky-heaven/p/10690782.html

[https_www.cnblogs.com_zxc2man_p_6604290.html]: https://www.cnblogs.com/zxc2man/p/6604290.html
[workqueue - G-tech - G-tech]: http://img.ph.126.net/p_C6FzYhwCYWwVW-5gpH-w==/2588443885848004903.jpg
[workqueue - G-tech - G-tech 1]: http://img.ph.126.net/rZsge6PfgKl-eqAtzhJ1Ew==/1180506052341303445.jpg
[workqueue - G-tech - G-tech 2]: http://img.ph.126.net/6V9eP_U54CZEtfwCjpB06A==/2620250558216309648.jpg
[workqueue - G-tech - G-tech 3]: http://img.ph.126.net/iQcaaVF0lYD_e8SFgO6ROw==/2767743446012693115.jpg