工作队列的使用过程:

简介: 工作队列的使用过程:

工作队列的使用过程:

工作队列相关函数介绍:

#include <workqueue.h> /*头文件包含*/

1.工作队列的创建及销毁:

    定义一个工作队列结构体指针

        static struct workqueue_struct *key_workqueue;

    创建工作队列

        struct workqueue_struct *create_workqueue(char *);

        参数:工作队列的名称(字符串)

        返回值:创建好的工作队列

    销毁工作队列,参数为待销毁的工作队列

        void destroy_workqueue(struct workqueue_struct *);


2.工作的创建、初始化

    创建一个不带延时的工作(加入队列立即执行)

        struct work_struct work;

    工作初始化宏

        INIT_WORK(&work, func);

        参数1:用户已定义的work_struct变量(工作)

        参数2:任务处理函数,用户实现(中断底半部)

3.添加工作到工作队列

    int queue_work(struct workqueue_struct*wq,struct work_struct *work);

    参数1:第1部创建的工作队列

    参数2:第2部创建的工作

4.延迟工作的创建、初始化及添加:

    定义一个带延时的工作

        struct delayed_work dwork;

    初始化带延迟的工作

        INIT_DELAYED_WORK(&dwork, func);

    添加带延迟的工作到工作队列

        int queue_delayed_work(struct workqueue_struct *wq,

                    struct delayed_work *dwork, unsigned long delay);

        参数delay:延迟时间(时钟滴答数)

        【注】对于我们的开发板,一个时钟滴答=5ms

    终止队列中的工作(即使处理程序已经在处理该任务)

        int cancel_work_sync(struct work_struct *work);

        int cancel_delayed_work_sync(struct delayed_work *dwork);

    判断任务项目是否在进行中

    int work_pending(struct work_struct work );

    int delayed_work_pending(structdelayed_work work );

    /*返回值为真表示正在运行,假表示停止*/

总结:

实例代码:
驱动端:

#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <mach/gpio.h>
#include <mach/regs-gpio.h>          /*S5PV210_GPH3_BASE*/
 
#include <linux/workqueue.h>
 
#define EINT_DEVICE_ID            1
 
#define DRIVER_NAME                "key1_eint"
#define err(msg)                 printk(KERN_ERR "%s: " msg "\n", DRIVER_NAME)
#define __debug(fmt, arg...)    printk(KERN_DEBUG fmt, ##arg)
 
#define GPH0_CONREG            (S5PV210_GPH0_BASE + 0x00)
#define GPH0_DATREG            (S5PV210_GPH0_BASE + 0x04)
#define GPH0_UPREG            (S5PV210_GPH0_BASE + 0x08)
#define GPH0_DRVREG            (S5PV210_GPH0_BASE + 0x0c)
 
#define GPH3CON                    (unsigned long)(S5PV210_GPH3_BASE+ 0x00)
#define GPH3DAT                    (unsigned long)(S5PV210_GPH3_BASE + 0x04)
#define GPH2UP                    (unsigned long)(S5PV210_GPH2_BASE + 0x08)
 
static int major = 0;        /* Driver Major Number */
static int minor = 0;        /* Driver Minor Number */
struct class *key_class;
static struct device *key_device;
 
static unsigned char key;
 
 
/* 定义工作队列指针变量,并定义工作变量。
 * 在此例中我们采用自定义的方式(我们还可以
 * 使用内核提供的工作队列,请参考ppt)
 */
static struct workqueue_struct *key_workqueue;
//static struct work_struct key_work;
static struct delayed_work key_work;
static struct work_struct key_work1;
 
 
 
/* 工作处理函数work_handler
 * 该函数完成点亮/熄灭led灯的功能
 */
static void work_handler(struct work_struct *work)
{
    unsigned long reg_data;
 
    reg_data = readl(GPH0_DATREG);
    reg_data ^= 0x01<<3;
    writel(reg_data, GPH0_DATREG);
    
}
static void work_handler1(struct work_struct *work)
{
    printk("haha you done\n");
    
}
 
 
irqreturn_t buttons_interrupt(int irq, void *dev_id)
{    
    key = (unsigned int)dev_id;
    //__debug("in eint function...\n");
 
    /*将work添加到工作队列workqueue中*/
    //queue_work(key_workqueue, &key_work);
    queue_delayed_work(key_workqueue,&key_work,1000);
    queue_work(key_workqueue, &key_work1);
    return IRQ_HANDLED;
}
 
/* the initialization of IO ports
 * @prepare for key device and led device
 */
static void led_io_port_init(void)
{
    unsigned long con_val, up_val;
    
    con_val = readl(GPH0_CONREG);    
    con_val &= ~(0x0f<<12);
    con_val |= (0x01<<12);    
    writel(con_val, GPH0_CONREG);
 
    up_val = readl(GPH0_UPREG);
    up_val &= ~(0X03<<6);
    up_val |= (0X02<<6);
    writel(up_val, GPH0_UPREG);
}
 
static void key_io_port_init(void)
{
    unsigned long reg_val;
    
    reg_val = readl(GPH3CON);
    reg_val &= ~((0x0f<<0) | (0x0f<<4));
    reg_val |= ((0x01<<0) | (0x01<<4));
    writel(reg_val, GPH3CON);
 
    reg_val = readl(GPH3DAT);
    reg_val &= ~((0x01<<0) | (0x01<<1));
    writel(reg_val, GPH3DAT);
 
    reg_val = readl(GPH2UP);
    reg_val &= ~(0x03<<8);
    reg_val |= 0x02<<8;
    writel(reg_val, GPH2UP);
}
 
static ssize_t key_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)
{
    int key_num;
    int cpy_len;
    int retval;
 
    key_num = key;        //读取键值
    key = 0;                //清除键值
    
    cpy_len = min(sizeof(key_num), count);
    retval = copy_to_user(buf, &key_num, cpy_len);
    
    return (cpy_len - retval);
}
 
static struct file_operations key_fops = {
    .owner = THIS_MODULE,
    .read = key_read,
};
 
static int __init key_eint_init(void)
{
    int retval;
    
 
    key_io_port_init();
    led_io_port_init();
    
    /* 创建工作队列--workqueue*/
    key_workqueue = create_workqueue("key_workqueue");
    if(IS_ERR(key_workqueue)){
        err("ceate workqueue failed!");
        return PTR_ERR(key_workqueue);
    }
    /*初始化工作--work, 指定处理函数work_handler*/
    //INIT_WORK(&key_work, work_handler);
    INIT_DELAYED_WORK(&key_work,work_handler);
    INIT_WORK(&key_work1, work_handler1);
    
    retval = set_irq_type(IRQ_EINT(20),IRQ_TYPE_EDGE_FALLING);
    if(retval){
        err("IRQ_EINT20 set irq type failed");
        goto error;
    }
    
    retval = request_irq(IRQ_EINT(20), buttons_interrupt, IRQF_DISABLED, 
            "KEY1", (void *)EINT_DEVICE_ID);
    if(retval){
        err("request eint20 failed");
        goto error;
    }
    
    /* Driver register */
    major = register_chrdev(major, DRIVER_NAME, &key_fops);
    if(major < 0){
        err("register char device fail");
        retval = major;
        goto error_register;
    }
    key_class=class_create(THIS_MODULE,DRIVER_NAME);
    if(IS_ERR(key_class)){
        err("class create failed!");
        retval =  PTR_ERR(key_class);
        goto error_class;
    }
    key_device=device_create(key_class,NULL, MKDEV(major, minor), NULL,DRIVER_NAME);
    if(IS_ERR(key_device)){
        err("device create failed!");
        retval = PTR_ERR(key_device);
        goto error_device;
    }
    __debug("register myDriver OK! Major = %d\n", major);
    return 0;
 
error_device:
    class_destroy(key_class);
error_class:
    unregister_chrdev(major, DRIVER_NAME);
error_register:
    free_irq(IRQ_EINT(20), (void *)EINT_DEVICE_ID);
error:
    return retval;
}
 
static void __exit key_eint_exit(void)
{
    /*清空工作队列*/
    flush_workqueue(key_workqueue);
    /*释放创建的工作队列,资源回收*/
    destroy_workqueue(key_workqueue);
    
    free_irq(IRQ_EINT(20), (void *)EINT_DEVICE_ID);
 
    unregister_chrdev(major, DRIVER_NAME);
    device_destroy(key_class,MKDEV(major, minor));
    class_destroy(key_class);
 
    return;
}
 
module_init(key_eint_init);
module_exit(key_eint_exit);
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Eric");


应用层:

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
 
int main()
{
    char *devname = "/dev/key1_eint";
    int fd;
    unsigned char key;
    
    fd = open(devname, O_RDWR);
    while(1)
    {
        read(fd, &key, sizeof(key)); 
        if(key)
            printf("the key = %d\n",key);
        usleep(100*1000);
    }
    close(fd);
}

————————————————

目录
相关文章
|
Linux API 调度
Linux设备驱动workqueue(工作队列)案例实现
Linux设备驱动workqueue(工作队列)案例实现
258 0
|
Java 调度
多线程学习(三)那些队列可用于线程池
多线程学习(三)那些队列可用于线程池
87 0
|
23天前
|
缓存 C语言
线程的创建过程
【9月更文挑战第15天】线程是由内核和用户态协同实现的机制。`pthread_create` 函数在 Glibc 中定义,首先处理线程属性参数,如栈大小,默认值或传入值。每个线程有一个 `pthread` 结构来维护状态。创建线程时,需要分配线程栈,并进行以下操作:获取栈大小、设置保护区域、缓存管理、内存映射、栈初始化及保护、填充 `pthread` 结构并管理栈缓存。最终通过 `create_thread` 函数调用 `clone` 系统调用创建线程,共享进程数据结构
|
2月前
|
存储 监控 Java
|
4月前
|
Java
【技术解码】Java线程的五味人生:新建、就绪、运行、阻塞与死亡的哲学解读!
【6月更文挑战第19天】Java线程生命周期如同人生旅程,经历新建、就绪、运行、阻塞至死亡五阶段。从`new Thread()`的诞生到`start()`的蓄势待发,再到`run()`的全力以赴,线程在代码中奔跑。阻塞时面临挑战,等待资源释放,最终通过`join()`或中断结束生命。线程的每个状态转变,都是编程世界与哲思的交汇点。
29 1
|
5月前
|
消息中间件 监控 前端开发
面试官:核心线程数为0时,线程池如何执行?
线程池是 Java 中用于提升程序执行效率的主要手段,也是并发编程中的核心实现技术,并且它也被广泛的应用在日常项目的开发之中。那问题来了,如果把线程池中的核心线程数设置为 0 时,线程池是如何执行的? 要回答这个问题,我们首先要了解在正常情况下,线程池的执行流程,也就是说当有一个任务来了之后,线程池是如何运行的? ## 1.线程池的执行流程 正常情况下(核心线程数不为 0 的情况下)线程池的执行流程如下: 1. **判断核心线程数**:先判断当前工作线程数是否大于核心线程数,如果结果为 false,则新建线程并执行任务。 2. **判断任务队列**:如果大于核心线程数,则判断任务队列是否
126 1
面试官:核心线程数为0时,线程池如何执行?
|
5月前
|
Java 调度
多线程的基本概念和实现方式,线程的调度,守护线程、礼让线程、插入线程
多线程的基本概念和实现方式,线程的调度,守护线程、礼让线程、插入线程
48 0
|
5月前
|
设计模式 Java
Java多线程实战-从零手搓一个简易线程池(三)线程工厂,核心线程与非核心线程逻辑实现
Java多线程实战-从零手搓一个简易线程池(三)线程工厂,核心线程与非核心线程逻辑实现
|
12月前
|
存储 安全 Java
【线程池添加工作线程的流程】
【线程池添加工作线程的流程】
|
Linux
Linux线程的生产者消费者模型 --- 阻塞队列(blockqueue)(二)
Linux线程的生产者消费者模型 --- 阻塞队列(blockqueue)(二)
88 0