linux定时器实现
如何使用crontab命令在Linux中设置定时任务

如何使用crontab命令在Linux中设置定时任务在Linux中设置定时任务是一项非常重要的技能,它可以帮助我们自动化重复性的任务,提高工作效率。
而crontab命令是Linux系统中用来管理定时任务的工具。
本文将介绍如何使用crontab命令来设置定时任务。
一、什么是crontab命令Crontab(Cron Table)是Linux系统中用来管理定时任务的工具,它允许用户在指定的时间自动执行特定的命令或脚本。
Crontab命令是由cron守护进程控制的,该守护进程会在指定的时间间隔内检查用户的crontab文件,并执行相应的任务。
二、创建和编辑crontab文件要创建和编辑crontab文件,可以使用以下命令:```crontab -e```这个命令会打开一个文本编辑器,你可以在其中添加或修改定时任务。
三、crontab文件的格式crontab文件中每一行代表一个定时任务,格式如下:分时日月周命令```其中,分表示分钟,时表示小时,日表示日期,月表示月份,周表示星期。
命令是要执行的命令或脚本。
每个字段可以是一个具体的数值,也可以是一个用逗号分隔的数值列表,或者是一个数值范围。
四、设置定时任务的示例以下是一些使用crontab命令设置定时任务的示例:1. 每天晚上8点执行一个命令:```0 20 * * * command```2. 每隔5分钟执行一个命令:```*/5 * * * * command```3. 每个月的1号凌晨3点执行一个命令:```0 3 1 * * command4. 每周一到周五的上午9点执行一个命令:```0 9 * * 1-5 command```五、常用的时间单位符号在crontab文件中,我们可以使用一些特殊的时间单位符号,如下所示:- *:代表所有值,比如在分钟字段中使用 * 表示每分钟都执行。
- */n:表示每隔n个单位执行一次,比如在小时字段中使用 */2 表示每隔两个小时执行一次。
linux 内核定时器timer_list详解

在模块的编写过程中,我们经常使用定时器来等待一段时间之后再来执行某一个操作。
为方便分析,写了下列一段测试程序:#include <linux/config.h>#include <linux/kernel.h>#include <linux/module.h>#include <linux/interrupt.h>#include <linux/delay.h>#include <linux/timer.h>MODULE_LICENSE("GPL");void test_timerfuc(unsigned long x){printk("Eric xiao test ......\n");}//声明一个定个器struct timer_list test_timer = TIMER_INITIALIZER(test_timerfuc, 0, 0);int kernel_test_init(){printk("test_init\n");//修改定时器到期时间。
为3个HZ。
一个HZ产生一个时钟中断mod_timer(&test_timer,jiffies+3*HZ);//把定时器加入时钟软中断处理链表add_timer(&test_timer);}int kernel_test_exit(){printk("test_exit\n");return 0;}module_init(kernel_test_init);module_exit(kernel_test_exit);上面的例子程序比较简单,我们从这个例子开始研究linux下的定时器实现。
TIMER_INITIALIZER():1):TIMER_INITIALIZER()用来声明一个定时器,它的定义如下:#define TIMER_INITIALIZER(_function, _expires, _data) { \.function = (_function), \.expires = (_expires), \.data = (_data), \.base = NULL, \.magic = TIMER_MAGIC, \.lock = SPIN_LOCK_UNLOCKED, \}Struct timer_list定义如下:struct timer_list {//用来形成链表struct list_head entry;//定始器到达时间unsigned long expires;spinlock_t lock;unsigned long magic;//定时器时间到达后,所要运行的函数void (*function)(unsigned long);//定时器函数对应的参数unsigned long data;//挂载这个定时器的tvec_t_base_s.这个结构我们等会会看到,当该次中断顺利执行后,该值也将清空为NULLstruct tvec_t_base_s *base;};从上面的过程中我们可以看到TIMER_INITIALIZER()只是根据传入的参数初始化了struct timer_list结构.并把magic 成员初始化成TIMER_MAGIC2): mod_timer():修改定时器的到时时间int mod_timer(struct timer_list *timer, unsigned long expires){//如果该定时器没有定义fuctionBUG_ON(!timer->function);//判断timer的magic是否为TIMER_MAGIC.如果不是,则将其修正为TIMER_MAGIC check_timer(timer);//如果要调整的时间就是定时器的定时时间而且已经被激活,则直接返回if (timer->expires == expires && timer_pending(timer))return 1;//调用_mod_timer().呆会再给出分析return __mod_timer(timer, expires);}3): add_timer()用来将定时器挂载到定时软中断队列,激活该定时器static inline void add_timer(struct timer_list * timer){__mod_timer(timer, timer->expires);}可以看到mod_timer与add_timer 最后都会调用__mod_timer().为了分析这个函数,我们先来了解一下定时系统相关的数据结构.tvec_bases: per cpu变量,它的定义如下:static DEFINE_PER_CPU(tvec_base_t, tvec_bases) = { SPIN_LOCK_UNLOCKED };由此可以看到tves_bases的数型数据为teves_base_t.数据结构的定义如下:typedef struct tvec_t_base_s tvec_base_t;struct tvec_t_base_s的定义:struct tvec_t_base_s {spinlock_t lock;//上一次运行计时器的jiffies 值这个值很关键,正是这个值保证了不会遗漏定时器中断,timer中断中每次循环查找后,该值加一unsigned long timer_jiffies;struct timer_list *running_timer;//tv1 tv2 tv3 tv4 tv5是五个链表数组tvec_root_t tv1;tvec_t tv2;tvec_t tv3;tvec_t tv4;tvec_t tv5;} ____cacheline_aligned_in_smp;Tves_root_t与tvec_t的定义如下:#define TVN_BITS 6#define TVR_BITS 8#define TVN_SIZE (1 << TVN_BITS)#define TVR_SIZE (1 << TVR_BITS)#define TVN_MASK (TVN_SIZE - 1)#define TVR_MASK (TVR_SIZE - 1)typedef struct tvec_s {struct list_head vec[TVN_SIZE];} tvec_t;typedef struct tvec_root_s {struct list_head vec[TVR_SIZE];} tvec_root_t;系统规定定时器最大超时时间间隔为0xFFFFFFFF.即为一个32位数.即使在64位系统上.如果超过此值也会将其强制设这oxFFFFFFFF(这在后面的代码分析中可以看到).内核最关心的就是间隔在0~255个HZ之间的定时器.次重要的是间隔在255~1<<(8+6)之间的定时器.第三重要的是间隔在1<<(8+6) ~ 1<<(8+6+6)之间的定器.依次往下推.也就是把32位的定时间隔为份了五个部份.1个8位.4个6位.所以内核定义了五个链表数组.第一个链表数组大小为8位大小,也即上面定义的 #define TVR_SIZE (1 << TVR_BITS).其它的四个数组大小为6位大小.即上面定义的#define TVN_SIZE (1 << TVN_BITS)在加入定时器的时候,按照时间间隔把定时器加入到相应的数组即可.了解这点之后,就可以来看__mod_timer()的代码了://修改timer或者新增一个timer都会调用此接口int __mod_timer(struct timer_list *timer, unsigned long expires){tvec_base_t *old_base, *new_base;unsigned long flags;int ret = 0;//入口参数检测BUG_ON(!timer->function);check_timer(timer);spin_lock_irqsave(&timer->lock, flags);//取得当前CPU对应的tvec_basesnew_base = &__get_cpu_var(tvec_bases);repeat://该定时器所在的tvec_bases.对于新增的timer.它的base字段为NULLold_base = timer->base;/** Prevent deadlocks via ordering by old_base < new_base.*///在把timer从当前tvec_bases摘下来之前,要充分考虑好竞争的情况if (old_base && (new_base != old_base)) {//按次序获得锁if (old_base < new_base) {spin_lock(&new_base->lock);spin_lock(&old_base->lock);} else {spin_lock(&old_base->lock);spin_lock(&new_base->lock);}/** The timer base might have been cancelled while we were* trying to take the lock(s):*///如果timer->base != old_base.那就是说在Lock的时候.其它CPU更改它的值 //那就解锁.重新判断if (timer->base != old_base) {spin_unlock(&new_base->lock);spin_unlock(&old_base->lock);goto repeat;}} else {//old_base == NULl 或者是 new_base==old_base的情况//获得锁spin_lock(&new_base->lock);//同理,在Lock的时候timer会生了改变if (timer->base != old_base) {spin_unlock(&new_base->lock);goto repeat;}}/** Delete the previous timeout (if there was any), and install* the new one:*///将其从其它的tvec_bases上删除.注意运行到这里的话,说话已经被Lock了 if (old_base) {list_del(&timer->entry);ret = 1;}//修改它的定时器到达时间timer->expires = expires;//将其添加到new_base中internal_add_timer(new_base, timer);//修改base字段timer->base = new_base;//操作完了,解锁if (old_base && (new_base != old_base))spin_unlock(&old_base->lock);spin_unlock(&new_base->lock);spin_unlock_irqrestore(&timer->lock, flags);return ret;}internal_add_timer()的代码如下:static void internal_add_timer(tvec_base_t *base, struct timer_list *timer){//定时器到达的时间unsigned long expires = timer->expires;//计算时间间间隔unsigned long idx = expires - base->timer_jiffies;struct list_head *vec;//根据时间间隔,将timer放入相应数组的相应位置if (idx < TVR_SIZE) {int i = expires & TVR_MASK;vec = base->tv1.vec + i;} else if (idx < 1 << (TVR_BITS + TVN_BITS)) {int i = (expires >> TVR_BITS) & TVN_MASK;vec = base->tv2.vec + i;} else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;vec = base->tv3.vec + i;} else if (idx < 1 << (TVR_BITS + 3 * TVN_BITS)) {int i = (expires >> (TVR_BITS + 2 * TVN_BITS)) & TVN_MASK;vec = base->tv4.vec + i;} else if ((signed long) idx < 0) {/** Can happen if you add a timer with expires == jiffies,* or you set a timer to go off in the past*///如果间隔小于0vec = base->tv1.vec + (base->timer_jiffies & TVR_MASK);} else {int i;/* If the timeout is larger than 0xffffffff on 64-bit* architectures then we use the maximum timeout:*///时间间隔超长,将其设为oxFFFFFFFFif (idx > 0xffffffffUL) {idx = 0xffffffffUL;expires = idx + base->timer_jiffies;}i = (expires >> (TVR_BITS + 3 * TVN_BITS)) & TVN_MASK;vec = base->tv5.vec + i;}/** Timers are FIFO:*///加入到链表末尾list_add_tail(&timer->entry, vec);}计算时间间隔即可知道要加入到哪一个数组.哪又怎么计算加入到该数组的那一项呢?对于间隔时间在0~255的定时器: 它的计算方式是将定时器到达时间的低八位与低八位为1的数相与而成对于第1个六位,它是先将到达时间右移8位.然后与低六位全为1的数相与而成对于第2个六位, 它是先将到达时间右移8+6位.然后与低六位全为1的数相与而成依次为下推…在后面结合超时时间到达的情况再来分析相关部份4):定时器更新每过一个HZ,就会检查当前是否有定时器的定时器时间到达.如果有,运行它所注册的函数,再将其删除.为了分析这一过程,我们先从定时器系统的初始化看起.asmlinkage void __init start_kernel(void){……init_timers();……}Init_timers()的定义如下:void __init init_timers(void){timer_cpu_notify(&timers_nb, (unsigned long)CPU_UP_PREPARE,(void *)(long)smp_processor_id());register_cpu_notifier(&timers_nb);//注册TIMER_SOFTIRQ软中断open_softirq(TIMER_SOFTIRQ, run_timer_softirq, NULL);}timer_cpu_notify()àinit_timers_cpu():代码如下:static void /* __devinit */ init_timers_cpu(int cpu){int j;tvec_base_t *base;//初始化各个数组中的链表base = &per_cpu(tvec_bases, cpu);spin_lock_init(&base->lock);for (j = 0; j < TVN_SIZE; j++) {INIT_LIST_HEAD(base->tv5.vec + j);INIT_LIST_HEAD(base->tv4.vec + j);INIT_LIST_HEAD(base->tv3.vec + j);INIT_LIST_HEAD(base->tv2.vec + j);}for (j = 0; j < TVR_SIZE; j++)INIT_LIST_HEAD(base->tv1.vec + j);//将最近到达时间设为当前jiffiesbase->timer_jiffies = jiffies;}我们在前面分析过,每当时钟当断函数到来的时候,就会打开定时器的软中断.运行其软中断函数.run_timer_softirq()代码如下:static void run_timer_softirq(struct softirq_action *h){//取得当于CPU的tvec_base_t结构tvec_base_t *base = &__get_cpu_var(tvec_bases);//如果jiffies > base->timer_jiffiesif (time_after_eq(jiffies, base->timer_jiffies))__run_timers(base);}__run_timers()代码如下:static inline void __run_timers(tvec_base_t *base){struct timer_list *timer;unsigned long flags;spin_lock_irqsave(&base->lock, flags);//因为CPU可能关闭中断,引起时钟中断信号丢失.可能jiffies要大base->timer_jiffies 好几个//HZwhile (time_after_eq(jiffies, base->timer_jiffies)) {//定义并初始化一个链表struct list_head work_list = LIST_HEAD_INIT(work_list);struct list_head *head = &work_list;int index = base->timer_jiffies & TVR_MASK;/** Cascade timers:*///当index == 0时,说明已经循环了一个周期//则将tv2填充tv1.如果tv2为空,则用tv3填充tv2.依次类推......if (!index &&(!cascade(base, &base->tv2, INDEX(0))) &&(!cascade(base, &base->tv3, INDEX(1))) &&!cascade(base, &base->tv4, INDEX(2)))cascade(base, &base->tv5, INDEX(3));//更新base->timer_jiffies++base->timer_jiffies;//将base->tv1.vec项移至work_list.并将base->tv1.vec置空list_splice_init(base->tv1.vec + index, &work_list);repeat://work_List中的定时器是已经到时的定时器if (!list_empty(head)) {void (*fn)(unsigned long);unsigned long data;//遍历链表中的每一项.运行它所对应的函数,并将定时器从链表上脱落timer = list_entry(head->next,struct timer_list,entry);fn = timer->function;data = timer->data;list_del(&timer->entry);set_running_timer(base, timer);smp_wmb();timer->base = NULL;spin_unlock_irqrestore(&base->lock, flags);fn(data);spin_lock_irq(&base->lock);goto repeat;}}set_running_timer(base, NULL);spin_unlock_irqrestore(&base->lock, flags);}如果base->timer_jiffies低八位为零.说明它向第九位有进位.所以把第九位到十五位对应的定时器搬到前八位对应的数组.如果第九位到十五位为空的话.就到它的上个六位去搬数据.上面的代码也说明.要经过1<<8个HZ才会更新全部数组中的定时器.这样做的效率是很高的. 分析下里面的两个重要的子函数:static int cascade(tvec_base_t *base, tvec_t *tv, int index){/* cascade all the timers from tv up one level */struct list_head *head, *curr;//取数组中序号对应的链表head = tv->vec + index;curr = head->next;/** We are removing _all_ timers from the list, so we don't have to* detach them individually, just clear the list afterwards.*///遍历这个链表,将定时器重新插入到base中while (curr != head) {struct timer_list *tmp;tmp = list_entry(curr, struct timer_list, entry);BUG_ON(tmp->base != base);curr = curr->next;internal_add_timer(base, tmp);}//将链表设为初始化状态INIT_LIST_HEAD(head);return index;}//将list中的数据放入head中,并将list置为空static inline void list_splice_init(struct list_head *list, struct list_head *head) {if (!list_empty(list)) {__list_splice(list, head);INIT_LIST_HEAD(list);}}//将list中的数据放入headstatic inline void __list_splice(struct list_head *list, struct list_head *head){//list的第一个元素struct list_head *first = list->next;//list的最后一个元素struct list_head *last = list->prev;//head的第一个元素struct list_head *at = head->next;将first对应的链表链接至headfirst->prev = head;head->next = first;//将head 原有的数据加入到链表末尾last->next = at;at->prev = last;}5):del_timer()删除定时器//删除一个timerint del_timer(struct timer_list *timer){unsigned long flags;tvec_base_t *base;check_timer(timer);repeat:base = timer->base;//该定时器没有被激活if (!base)return 0;//加锁spin_lock_irqsave(&base->lock, flags);//如果在加锁的过程中,有其它操作改变了timerif (base != timer->base) {spin_unlock_irqrestore(&base->lock, flags);goto repeat;}//将timer从链表中删除list_del(&timer->entry);timer->base = NULL;spin_unlock_irqrestore(&base->lock, flags);return 1;}6): del_timer_sync()有竞争情况下的定时器删除在SMP系统中,可能要删除的定时器正在某一个CPU上运行.为了防止这种在情况.在删除定时器的时候,应该优先使用del_timer_synsc().它会一直等待所有CPU上的定时器执行完成. int del_timer_sync(struct timer_list *timer){tvec_base_t *base;int i, ret = 0;check_timer(timer);del_again://删除些定时器ret += del_timer(timer);//遍历CPUfor_each_online_cpu(i) {base = &per_cpu(tvec_bases, i);//如果此CPU正在运行这个timerif (base->running_timer == timer) {//一直等待,直到这个CPU执行完while (base->running_timer == timer) {cpu_relax();preempt_check_resched();}break;}}smp_rmb();//如果这个timer又被调用.再删除if (timer_pending(timer))goto del_again;return ret;}定时器部份到这里就介绍完了.为了管理定时器.内核用了一个很巧妙的数据结构.值得好好的体会.。
Linux定时器timerfd用法

Linux定时器timerfd⽤法⽬录timerfd特点timerfd的特点是将时间变成⼀个⽂件描述符,定时器超时时,⽂件可读。
这样就能很容易融⼊select(2)/poll(2)/epoll(7)的框架中,⽤统⼀的⽅式来处理IO事件、超时事件。
这也是Reactor模式的特点。
timerfd定时器与传统Reactor模式定时器传统Reactor模式使⽤select/poll/epoll 的timeout参数实现定时功能,但其精度只有毫秒(注意区分表⽰精度和实际精度,表⽰精度可能为微妙和纳秒)。
另外,select/poll/epoll的定时器也有⼀个缺陷,那就是只能针对的是所有监听的⽂件描述符fd,⽽⾮绑定某个fd。
timerfd可以解决这个问题,单独为某个fd指定定时器。
timerfd接⼝timerfd包含3个接⼝:timerfd_create,timerfd_settime,timerfd_gettime。
#include <sys/timerfd.h>int timerfd_create(int clockid, int flags);int timerfd_settime(int fd, int flags, const struct itimerspec *new_value, struct itimerspec *old_value);int timerfd_gettime(int fd, struct itimerspec *curr_value);1)timerfd_create ⽤于创建定时器对象,返回⼀个指向该定时器的fd。
参数clockid ⽤于创建定时器的过程,只能是CLOCK_REALTIME或CLOCK_MONOTONIC。
CLOCK_REALTIME表⽰创建⼀个可设置的系统范围的时钟(system-wide clock)。
CLOCK_MONOTONIC表⽰创建⼀个不可设置的时钟,不受系统时钟中的⾮连续改变的影响(例如,⼿动改变系统时间)flags 选项,值能按位或,可⽤于改变timerfd_create()⾏为。
Linux系统重启脚本使用Shell脚本实现对Linux系统的定时重启和自动恢复

Linux系统重启脚本使用Shell脚本实现对Linux系统的定时重启和自动恢复Linux系统是一种广泛使用的操作系统,它在服务器和嵌入式设备中得到了广泛应用。
在实际运行过程中,为了确保系统的正常运行和稳定性,定时重启和自动恢复是必不可少的功能。
本文将介绍如何使用Shell脚本来实现对Linux系统的定时重启和自动恢复。
实施定时重启功能的第一步是创建一个Shell脚本。
通过使用Linux 的定时任务工具cron,我们可以在指定的时间自动运行这个脚本。
打开终端,输入以下命令创建一个新的脚本文件:```shell$ sudo nano restart.sh```接下来,我们需要编写重启脚本的内容。
在脚本中,我们将使用`shutdown`命令来实现重启功能。
以下是一个示例脚本:```shell#!/bin/bashshutdown -r now```保存并关闭文件。
接下来,我们需要为脚本添加执行权限:```shell$ sudo chmod +x restart.sh```现在,我们可以使用cron来设置定时任务。
通过运行以下命令,我们可以编辑当前用户的cron表:```shell$ crontab -e```在cron表中,每行代表一个定时任务。
按下`i`键进入编辑模式,然后添加以下行来设置每天重启的时间:```30 2 * * * /path/to/restart.sh```这样,每天的凌晨2点30分,系统将自动重启。
修改完成后,按下`Esc`键,然后输入`:wq`保存并退出。
现在,我们已经完成了定时重启功能的设置。
从现在起,系统将在指定时间自动执行重启。
另外,为了确保系统在重启后能够自动恢复到之前的状态,我们还可以编写一个自动恢复脚本。
该脚本将在系统重启后自动运行,并执行一系列操作以将系统恢复到正常状态。
继续使用前面创建的`restart.sh`脚本,我们可以在其中添加自动恢复的操作。
以下是一个示例脚本:```shell#!/bin/bash# 这里是自动恢复的操作```在具体的自动恢复操作中,您可以根据实际需求执行需要的命令和操作,比如恢复数据库、重启服务等。
linux使用select实现精确定时器详解

linux使⽤select实现精确定时器详解在编写程序时,我们经常会⽤到定时器。
⾸先看看select函数原型如下:复制代码代码如下:int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);参数说明:slect的第⼀个参数nfds为fdset集合中最⼤描述符值加1,fdset是⼀个位数组,其⼤⼩限制为__FD_SETSIZE(1024),位数组的每⼀位代表其对应的描述符是否需要被检查。
select的第⼆三四个参数表⽰需要关注读、写、错误事件的⽂件描述符位数组,这些参数既是输⼊参数也是输出参数,可能会被内核修改⽤于标⽰哪些描述符上发⽣了关注的事件。
所以每次调⽤select前都需重新初始化fdset。
timeout参数为超时时间,该结构会被内核修改,其值为超时剩余的时间。
利⽤select实现定时器,需要利⽤其timeout参数,注意到:1)select函数使⽤了⼀个结构体timeval作为其参数。
2)select函数会更新timeval的值,timeval保持的值为剩余时间。
如果我们指定了参数timeval的值,⽽将其他参数都置为0或者NULL,那么在时间耗尽后,select函数便返回,基于这⼀点,我们可以利⽤select实现精确定时。
timeval的结构如下:复制代码代码如下:struct timeval{long tv_sec;/*secons*long tv_usec;/*microseconds*/}我们可以看出其精确到microseconds也即微妙。
⼀、秒级定时器复制代码代码如下:void seconds_sleep(unsigned seconds){struct timeval tv;_sec=seconds;_usec=0;int err;do{err=select(0,NULL,NULL,NULL,&tv);}while(err<0 && errno==EINTR);}⼆、毫秒级别定时器复制代码代码如下:void milliseconds_sleep(unsigned long mSec){struct timeval tv;_sec=mSec/1000;_usec=(mSec%1000)*1000;int err;do{err=select(0,NULL,NULL,NULL,&tv);}while(err<0 && errno==EINTR);}三、微妙级别定时器复制代码代码如下:void microseconds_sleep(unsigned long uSec){struct timeval tv;_sec=uSec/1000000;_usec=uSec%1000000;int err;do{err=select(0,NULL,NULL,NULL,&tv);}while(err<0 && errno==EINTR);}现在我们来编写⼏⾏代码看看定时效果吧。
Linux系统定时重启脚本

Linux系统定时重启脚本Linux是一种开源操作系统,广泛应用于服务器领域。
在运行服务器的过程中,有时我们需要定时重启系统以确保系统的稳定性和性能。
为了方便管理和操作,我们可以编写一个定时重启脚本来自动执行此任务。
以下是一个简单的Linux系统定时重启脚本示例:```bash#!/bin/bash# 重启时间设定(每天凌晨3点)reboot_hour=3reboot_minute=0# 获取当前时间current_hour=$(date +%H)current_minute=$(date +%M)# 计算距离下一次重启的时间间隔if [[ current_hour -eq reboot_hour ]]; thenif [[ current_minute -lt reboot_minute ]]; thenreboot_delay=$(( (reboot_minute - current_minute) * 60 ))fielsehour_diff=$(( reboot_hour - current_hour ))minute_diff=$(( reboot_minute - current_minute ))reboot_delay=$(( (hour_diff * 60 + minute_diff) * 60 ))fi# 等待时间间隔sleep $reboot_delay# 重启系统shutdown -r now```上述脚本首先设定了重启时间,这里以每天凌晨3点为例。
然后获取当前系统的时间,并计算距离下一次重启的时间间隔。
接着会根据时间间隔进行等待,到达指定时间后执行重启命令`shutdown -r now`来重启系统。
使用这个脚本,我们可以通过设置定时任务来实现自动定时重启。
可以使用`crontab`命令编辑定时任务列表,以下是一个示例:```bashsudo crontab -e```在打开的定时任务列表中,添加以下内容:```bash0 3 * * * /path/to/reboot_script.sh```这个定时任务会在每天凌晨3点执行`/path/to/reboot_script.sh`脚本,即我们之前编写的定时重启脚本。
linux中定时器的使用方法

linux中定时器的使用方法Linux是一个功能强大的操作系统,其中提供了许多工具来帮助用户管理和计划任务。
其中一个重要的工具是定时器,它可以在指定的时间间隔内执行某些操作。
本文将介绍Linux中定时器的使用方法。
1. 了解定时器的基本概念在Linux中,定时器是一种可重复执行的指令。
它们被设置在特定的时间段内,并在该时间段内自动执行。
定时器可以执行任何命令,如运行程序、创建文件、编辑文件、重启服务等。
2. 创建定时器要创建定时器,可以使用定时器脚本。
定时器脚本是一个简单的文件,包含定时器的指令和设置。
例如,可以使用以下命令来创建一个名为“crontab”的定时器脚本:```crontab -e```这将打开一个新的编辑器窗口,其中包含一个名为“crontab”的选项。
在这个窗口中,可以添加、编辑和删除定时器。
3. 编辑定时器要编辑定时器,需要使用“crontab”命令。
例如,可以使用以下命令来编辑一个已经存在的定时器:```crontab -e```在编辑定时器时,可以选择要使用的定时器、设置时间和日期,以及要自动执行的指令。
例如,要创建一个在每天下午3点定时执行“ls -l”命令的定时器,可以使用以下命令:```*/3 * * * * ls -l```这将在每天的下午3点自动执行“ls -l”命令。
请注意,“*/3 * * * *”是一个固定的指令,将在每个下午3点自动执行。
4. 删除定时器要删除定时器,可以使用“crontab”命令。
例如,可以使用以下命令来删除一个已经存在的定时器:```crontab -r```这将删除当前文件中的所有定时器。
5. 了解定时器的优点和限制定时器是一种非常有用的工具,可以帮助用户在特定时间执行某些操作。
虽然定时器可以提高效率,但也存在一些限制。
首先,定时器的设置是固定的,无法更改。
这意味着,如果希望在特定时间执行不同的操作,需要使用多个定时器。
其次,定时器不会在周末或节假日期间运行。
linux c语言定时器

linux c语言定时器linux c语言定时器2010-09-01 20:13linux定时器的使用使用定时器的目的无非是为了周期性的执行某一任务,或者是到了一个指定时间去执行某一个任务。
要达到这一目的,一般有两个常见的比较有效的方法。
一个是用linux内部的三个定时器,另一个是用sleep, usleep函数让进程睡眠一段时间,其实,还有一个方法,那就是用gettimeofday, difftime等自己来计算时间间隔,然后时间到了就执行某一任务,但是这种方法效率低,所以不常用。
首先来看看linux操作系统为每一个进程提供的3个内部计时器。
ITIMER_REAL: 给一个指定的时间间隔,按照实际的时间来减少这个计数,当时间间隔为0的时候发出SIGALRM信号ITIMER_VIRTUAL: 给定一个时间间隔,当进程执行的时候才减少计数,时间间隔为0的时候发出SIGVTALRM信号ITIMER_PROF: 给定一个时间间隔,当进程执行或者是系统为进程调度的时候,减少计数,时间到了,发出SIGPROF信号,这个和ITIMER_VIRTUAL联合,常用来计算系统内核时间和用户时间。
用到的函数有:#include <sys/time.h>int getitimer(int which, struct itimerval *value);int setitimer(int which, struct itimerval*newvalue, struct itimerval* oldvalue); strcut timeval{long tv_sec; /*秒*/long tv_usec; /*微秒*/};struct itimerval{struct timeval it_interval; /*时间间隔*/struct timeval it_value; /*当前时间计数*/};it_interval用来指定每隔多长时间执行任务, it_value用来保存当前时间离执行任务还有多长时间。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Linux定时器实现
在linux中实现定时器功能有多种方法,如sleep,alarm,和signal等,本文主要介绍使用time()和setitimer()函数来实现定时器功能。
使用time()实现定时器
time_t time(time_t *t);
如果t是空指针,直接返回当前时间。
如果t不是空指针,返回当前时间的同时,将返回值赋予t指向的内存空间。
设计思路:
1.首先获取初始时间
2.判断当前时间与初始时间差是否大于等于定时时间
3.如果满足条件则进行超时处理,并设置前时间为初始时间。
4.循环执行步骤2和3
#include <stdio.h>
#include <time.h>
#include <pthread.h>
time_t last_action; //初始时间或者上一次超时操作的时间
int timeout_v=5; //定时周期
//读取设置定时周期
void* recv_loop(void* data){
while(1){
printf("input timeout value:");
scanf("%d",&timeout_v);
}
}
int main(void){
pthread_t recv_thread;
//创建线程读取随时设置的定时周期
if(pthread_create(&recv_thread,0,recv_loop,0)){
printf("pthread_creat failed\n");
return -1;
}
time(&last_action);//获取当前时间
while(1){
//printf("timeout_v:%d\n",timeout_v);
if(time(NULL)-last_action>=timeout_v){//判断是否超时
printf("******timeout*******\n"); //超时处理
time(&last_action); //获取当前时间
}
}
}
以上程序实现的功能是,开始程序按照默认定时周期执行超时操作,打印******timeout*******。
同时该程序还可以随时设置定时周期时间,之后程序便根据新设定的定时周期执行超时操作。
使用setitimer()实现定时器
setitimer()为linux的API,而不是c标准库。
该函数有两个功能,一是指定一段时间后执行一个调用函数。
二是每间隔一段时间都执行一次调用函数。
该函数还有一个特点是,如果上一次定时时间还没有到,再次调用该函数的话,定时器会立即清零。
int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue));
struct itimerval {
struct timeval it_interval;
struct timeval it_value;
};
struct timeval {
long tv_sec;
long tv_usec;
};
其中,which为定时器类型,3中类型定时器如下:
ITIMER_REAL : 以系统真实的时间来计算,它送出SIGALRM信号。
ITIMER_VIRTUAL : -以该进程在用户态下花费的时间来计算,它送出SIGVTALRM 信号。
ITIMER_PROF : 以该进程在用户态下和内核态下所费的时间来计算,它送出SIGPROF信号。
第二个参数指定间隔时间,第三个参数用来返回上一次定时器的间隔时间,如果不关心该值可设为NULL。
it_interval指定间隔时间,it_value指定初始定时时间。
如果只指定it_value,就是实现一次定时;如果同时指定it_interval,则超时后,系统会重新初始化it_value为it_interval,实现重复定时;两者都清零,则会清除定时器。
tv_sec提供秒级精度,tv_usec提供微秒级精度,以值大的为先,注意1s = 1000000us。
如果是以setitimer提供的定时器来休眠,只需阻塞等待定时器信号就可以了。
setitimer()调用成功返回0,否则返回-1
设计思路:
调用setitimer时只设定初始定时时间,在第一次超时之后再调用setitimer设置初始时间。
由于setitimer函数超时后会产生相应的信号,那么可以使用signal()处理相应的信号,调用相应的函数,同时再次调用setitimer重新等待超时。
#include <stdio.h>
#include <sys/time.h>
#include <pthread.h>
#include <signal.h>
#include <string.h>
#include <unistd.h>
int time_value=5; //定时周期
struct itimerval timeout_v;
//调用定时函数,等到超时
void start_up_timer(void){
memset(&timeout_v,0,sizeof(struct itimerval));
timeout_v.it__sec=time_value;
timeout_v.it__usec=0;
//timeout_v.it__sec=time_value;
//timeout_v.it__usec=0
if(setitimer(ITIMER_REAL,&timeout_v,NULL))
printf("set timer failed\n");
}
//定时周期设置函数,并重启定时函数,清零当前定时时间
void* recv_loop(void* data){
while(1){
printf("input timeout value:");
scanf("%d",&time_value);
start_up_timer();
}
}
//超时调用函数,并重启定时函数。
void deal_timeout(int signo){
printf("******timeout******\n");
start_up_timer();
}
int main(void){
pthread_t recv_thread;
signal(SIGALRM,deal_timeout);
if(pthread_create(&recv_thread,0,recv_loop,0)){
printf("pthread_creat failed\n");
return -1;
}
start_up_timer();
while(1){
pause();//是进程休眠,等待信号到来
}
}
以上程序实现的功能是,开始程序按照默认定时周期执行超时操作,打印******timeout*******。
同时该程序还可以随时设置定时周期时间并立即清零定时器不管上次定时周期有没有结束,之后程序便根据新设定的定时周期执行超时操作。