如果我們需要在將來某個時間點排程執行某個動作，同時在該時間點到達之前不會阻塞當前程序，可以使用核心定時器。核心定時器可用來在未來的某個特定時間點排程執行某個函式，從而可用於完成許多工。
Linux 核心所提供的用於操作定時器的資料結構和函式（位於 <linux/timer.h>）如下

struct timer_list {
    /*
     * All fields that change during normal runtime grouped to the
     * same cacheline
     */
    struct list_head entry;        /* 定時器列表 */
    unsigned long expires;        /* 期望定時器執行的jiffies值 */
    struct tvec_base *base;

    void (*function)(unsigned long);/* 定時器處理函式 */
    unsigned long data;        /* 作為引數被傳入定時器處理函式 */

    int slack;

#ifdef CONFIG_TIMER_STATS
    int start_pid;
    void *start_site;
    char start_comm[16];
#endif
#ifdef CONFIG_LOCKDEP
    struct lockdep_map lockdep_map;
#endif
};
 

使用定時器必須初始化，使用函式

void init_timer(struct timer_list * timer);

然後還需為定時器結構成員expires、function、data（需要的話）賦值。
使用如下函式註冊定時器：

void add_timer(struct timer_list * timer);

這樣定時器將在expires之後執行函式function，不過此時只能執行一次，如果想在之後每個expires時間都執行function函式的話，需要在function函式裡面修改定時器expires的值。使用如下函式修改：

int mod_timer(struct timer_list *timer, unsigned long expires);
 

在定時器處理函式中,在做完相應的工作後,往往會延後 expires 並將定時器再次新增到核心定時器連結串列,以便定時器能再次被觸發。

一個示例如下：

#include <linux/module.h>
#include <linux/init.h>
#include <linux/version.h>

#include <linux/timer.h>
#include <linux/delay.h>

struct timer_list   sln_timer;

void sln_timer_do(unsigned long l)
{
    mod_timer(&sln_timer, jiffies + HZ);//HZ為1秒，在此時間之後繼續執行

    printk(KERN_ALERT"jiffies: %ld\n", jiffies);//簡單列印jiffies的值
}

void sln_timer_set(void)
{
    init_timer(&sln_timer);//初始化定時器

    sln_timer.expires = jiffies + HZ;   //1s後執行
    sln_timer.function = sln_timer_do;    //執行函式

    add_timer(&sln_timer);    //向核心註冊定時器
}

static int __init sln_init(void)
{
    printk(KERN_ALERT"===%s===\n", __func__);

    sln_timer_set();
    return 0;
}

static void __exit sln_exit(void)
{
    printk(KERN_ALERT"===%s===\n", __func__);

    del_timer(&sln_timer);//刪除定時器
}

module_init(sln_init);
module_exit(sln_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("sln");
 

像定時器這種週期性的任務還可以使用延時工作佇列來實現。
給一個示例：

#include <linux/module.h>
#include <linux/init.h>
#include <linux/version.h>

#include <linux/workqueue.h>
#include <linux/delay.h>

static struct workqueue_struct      *sln_wq = NULL;
static struct delayed_work          sln_dwq;


static void sln_do(struct work_struct *ws)
{
    queue_delayed_work(sln_wq, &sln_dwq, 1000);
    printk(KERN_ALERT"jiffies: %ld\n", jiffies);
}

static int __init sln_init(void)
{
    printk(KERN_ALERT"===%s===\n", __func__);

    sln_wq = create_workqueue("sln_work_queue");
    INIT_DELAYED_WORK(&sln_dwq, sln_do);
    queue_delayed_work(sln_wq, &sln_dwq, 0);

    return 0;
}

static void __exit sln_exit(void)
{
    printk(KERN_ALERT"===%s===\n", __func__);

    cancel_delayed_work(&sln_dwq);
    flush_workqueue(sln_wq);
    destroy_workqueue(sln_wq);
}

module_init(sln_init);
module_exit(sln_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("allen");