线程工作队列实例

#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <linux/platform_device.h>
#include <linux/compat.h>
#include <linux/of.h>
#include <linux/delay.h>
#include <linux/cdev.h>
#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/semaphore.h>
#include <linux/time.h>
#include <linux/wakelock.h>
#include <linux/miscdevice.h>
#include <linux/spinlock.h>
#include <linux/wait.h>
#include <linux/interrupt.h>
#include <linux/mm.h>
#include <linux/io.h>
#include <linux/switch.h>
#include <linux/string.h>
#include <linux/kthread.h>
#include <linux/kdev_t.h>
#include <linux/wakelock.h>
#include <linux/ctype.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/workqueue.h>


MODULE_AUTHOR("dreamice");
MODULE_LICENSE("Dual BSD/GPL");


#if 0
struct timer_data {
        struct timer_list timer;
        struct workqueue_struct *work_queue;
        unsigned long prev_jiffies;
        unsigned int loops;
};




struct timer_data test_data;
struct timer_data test_data1;
#endif


static void do_work(struct work_struct *work);
static void do_delayed_work(struct work_struct *work);


//static struct work_struct test_work;
///static delayed_work test_work1;


//static DECLARE_DELAYED_WORK(test_work, do_work);
static DECLARE_WORK(test_work, do_work);
static DECLARE_DELAYED_WORK(test_work1, do_delayed_work);


#if 0
static struct workqueue_struct *test_workqueue;


atomic_t wq_run_times;
unsigned int failed_cnt = 0;




static int work_delay = 2 * HZ; /* timer interval */


void test_timer_fn(unsigned long arg)
{
        struct timer_data *data = (struct timer_data *)arg;
        unsigned long j = jiffies;
        data->timer.expires += work_delay;
        data->prev_jiffies = j;
        add_timer(&data->timer);
        if (queue_work(test_workqueue, &test_work) == 0) {
                printk("Timer (0) add work queue failed\n");
                (*(&failed_cnt))++;
        }
        data->loops++;
        printk("timer-0 loops: %u\n", data->loops);
}






void test_timer_fn1(unsigned long arg)
{
        struct timer_data *data = (struct timer_data *)arg;
        unsigned long j = jiffies;
        data->timer.expires += 3 * HZ;
        data->prev_jiffies = j;
        add_timer(&data->timer);
        //if (queue_work(test_workqueue, &test_work) == 0) {


        if (queue_work(test_workqueue, &test_work1) == 0) {
                printk("Timer (1) add work queue failed\n");
                (*(&failed_cnt))++;
        }
        data->loops++;
        printk("timer-1 loops: %u\n", data->loops);
}


#endif






static void do_work(struct work_struct *work)
{
//        atomic_inc(&wq_run_times);
  //      printk("====work queue run times: %u====\n", atomic_read(&wq_run_times));
    //    printk("====failed count: %u====\n", *(&failed_cnt));


printk("xuzhoubin do work....\r\n");
}
//struct delayed_work *dwork
static void do_delayed_work(struct work_struct *dwork)
{
printk("xuzhoubin ....do delayed_work\r\n");
}




int wq_init(void)
{
      #if 0
unsigned long j = jiffies;
        printk("jiffies: %lu\n", jiffies);
        atomic_set(&wq_run_times, 0);


        init_timer(&test_data.timer);
        test_data.loops = 0;
        test_data.prev_jiffies = j;
        test_data.timer.function = test_timer_fn;
        test_data.timer.data = (unsigned long)(&test_data);
        test_data.timer.expires = j + 2 * HZ;
//        add_timer(&test_data.timer);


        init_timer(&test_data1.timer);
        test_data1.loops = 0;
        test_data1.prev_jiffies = j;
        test_data1.timer.function = test_timer_fn1;
        test_data1.timer.data = (unsigned long)(&test_data1);
        test_data1.timer.expires = j + 3 * HZ;
//        add_timer(&test_data1.timer);


        test_workqueue = create_singlethread_workqueue("test-wq");
#endif
// INIT_WORK(&test_work, do_work);
// INIT_WORK(&test_work1, do_work);
// INIT_DELAYED_WORK(&test_work1, do_delayed_work);
schedule_delayed_work(&test_work1, HZ * 2);
schedule_work(&test_work);
        printk("test-wq init success\n");
        printk("jiffies: %lu\n", jiffies);
        return 0;
}




void wq_exit(void)
{
//        del_timer(&test_data.timer);
  //      del_timer(&test_data1.timer);
    //    destroy_workqueue(test_workqueue);
        printk("wq exit success\n");
}




module_init(wq_init);
module_exit(wq_exit);

1.使用定时器开启工作队列：01。create_singlethread_workqueue 创建自己的线程,02 queue_work(test_workqueue, &test_work 定时器函数中让队列工作。

2.工作结构挂接到内核预定义的事件工作队列中调度

2.1 static DECLARE_WORK(test_work, do_work);
              static DECLARE_DELAYED_WORK(test_work1, do_delayed_work);

使用静态初始化。

2.2 // INIT_WORK(&test_work1, do_work);
// INIT_DELAYED_WORK(&test_work1, do_delayed_work);

使用动态初始化。

2.3

schedule_delayed_work(&test_work1, HZ * 2);
schedule_work(&test_work)

立即工作，延后工作。