定时器在Linux中的C

可能重复:
循环/定时器在C

我一直在读最近3天的计时器,我找不到任何有用的东西,我试图以实际的例子来理解它,有人可以帮我弄清楚如何为下面的程序设置一个闹钟。

我怎么能设置一个计时器,以便它会发送2个参数,一个是数组名称,第二个是要删除的数字,我知道下面是不安全的,我只是想了解如何使用带有参数的警报来调用一个函数。

请注意,环境是Linux,我也很欣赏任何与工作C例子的链接。

#include<stdio.h> int delete_from_array(int arg) ; int main() { int a[10000], i, y ; //how to set timer here for to delete any number in array after half a second for (y=0; y < 100; y++) { for (i=0; i<sizeof(a) / sizeof(int); i++) a[i] = i; sleep(1); printf("wake\n"); } } int delete_from_array(int arg) { int i, a[1000], number_to_delete=0; //number_to_delete = arg->number; for (i=0; i<sizeof(a); i++) if (a[i] == number_to_delete) a[i] = 0; printf("deleted\n"); } 

我想要做的是我有一个哈希值已过期1秒后,所以在我插入哈希值后,我需要创build一个计时器,以便它会删除后,让我们说的价值1秒,如果我在那个间隔(1秒)之前得到了服务器的响应,那么我从哈希中删除这个值并删除这个计时器,就像tcp中的重传一样

Solutions Collecting From Web of "定时器在Linux中的C"

你想使用信号或线程?

首先,建立信号处理程序或准备一个合适的线程函数; 详情请参阅man 7 sigevent 。

接下来,使用timer_create()创建一个合适的定时器。 有关详细信息,请参阅man 2 timer_create 。

根据您在计时器启动时所做的操作,您可能希望将计时器设置为一次性,或者之后在短时间内重复。 你使用timer_settime()来同时设定和撤防计时器。 有关详细信息,请参阅man 2 timer_settime 。

在实际应用中,您通常需要复用定时器。 即使一个进程可以创建多个定时器,它们也是一个有限的资源。 特别是超时定时器 – 无论是设置一个标志还是发送一个信号给一个特定的线程 – 都应该使用一个定时器,该定时器在下一次超时时触发,设置相关的超时标志,并可选地发送一个信号(与一个空体处理程序)到所需的线程,以确保它被打断。 (对于单线程进程,原始信号传递会中断阻塞的I / O调用。)考虑一个服务器,响应某个请求:请求本身在处理请求时可能会有一分钟左右的超时可能需要连接超时,I / O超时等等。

现在,原来的问题很有趣,因为定时器在有效使用时功能强大。 但是,示例程序基本上是无稽之谈。 你为什么不创建一个程序来设置一个或多个定时器,每个定时器例如输出一些东西到标准输出? 请记住使用来自unistd.h write()等,因为它们是异步信号安全的 ,而来自stdio.h printf()等不是。 (如果你的信号处理程序使用非异步信号安全函数,结果是不确定的,通常是有效的,但是不能保证;它可能和工作一样崩溃,测试不会显示,因为它是未定义的


编辑补充:这是一个复用超时的简单例子。

(尽可能根据法律规定,我将以下所示代码片段的所有版权及相关权利用于全世界的公有领域,请参阅CC0 Public Domain Dedication 。换言之,您可以随意使用以下代码希望,只是不要责怪我有任何问题。)

我使用旧式的GCC原子内置,所以它应该是线程安全的。 有一些补充,它应该也适用于多线程代码。 (你不能使用例如互斥体,因为pthread_mutex_lock()不是异步信号安全的。尽管可能会有一些竞争,但是如果你在禁用超时之前禁用了超时状态,则应该尽可能地处理超时状态。

 #define _POSIX_C_SOURCE 200809L #include <unistd.h> #include <signal.h> #include <time.h> #include <errno.h> #define TIMEOUTS 16 #define TIMEOUT_SIGNAL (SIGRTMIN+0) #define TIMEOUT_USED 1 #define TIMEOUT_ARMED 2 #define TIMEOUT_PASSED 4 static timer_t timeout_timer; static volatile sig_atomic_t timeout_state[TIMEOUTS] = { 0 }; static struct timespec timeout_time[TIMEOUTS]; /* Return the number of seconds between before and after, (after - before). * This must be async-signal safe, so it cannot use difftime(). */ static inline double timespec_diff(const struct timespec after, const struct timespec before) { return (double)(after.tv_sec - before.tv_sec) + (double)(after.tv_nsec - before.tv_nsec) / 1000000000.0; } /* Add positive seconds to a timespec, nothing if seconds is negative. * This must be async-signal safe. */ static inline void timespec_add(struct timespec *const to, const double seconds) { if (to && seconds > 0.0) { long s = (long)seconds; long ns = (long)(0.5 + 1000000000.0 * (seconds - (double)s)); /* Adjust for rounding errors. */ if (ns < 0L) ns = 0L; else if (ns > 999999999L) ns = 999999999L; to->tv_sec += (time_t)s; to->tv_nsec += ns; if (to->tv_nsec >= 1000000000L) { to->tv_nsec -= 1000000000L; to->tv_sec++; } } } /* Set the timespec to the specified number of seconds, or zero if negative seconds. */ static inline void timespec_set(struct timespec *const to, const double seconds) { if (to) { if (seconds > 0.0) { const long s = (long)seconds; long ns = (long)(0.5 + 1000000000.0 * (seconds - (double)s)); if (ns < 0L) ns = 0L; else if (ns > 999999999L) ns = 999999999L; to->tv_sec = (time_t)s; to->tv_nsec = ns; } else { to->tv_sec = (time_t)0; to->tv_nsec = 0L; } } } /* Return nonzero if the timeout has occurred. */ static inline int timeout_passed(const int timeout) { if (timeout >= 0 && timeout < TIMEOUTS) { const int state = __sync_or_and_fetch(&timeout_state[timeout], 0); /* Refers to an unused timeout? */ if (!(state & TIMEOUT_USED)) return -1; /* Not armed? */ if (!(state & TIMEOUT_ARMED)) return -1; /* Return 1 if timeout passed, 0 otherwise. */ return (state & TIMEOUT_PASSED) ? 1 : 0; } else { /* Invalid timeout number. */ return -1; } } /* Release the timeout. * Returns 0 if the timeout had not fired yet, 1 if it had. */ static inline int timeout_unset(const int timeout) { if (timeout >= 0 && timeout < TIMEOUTS) { /* Obtain the current timeout state to 'state', * then clear all but the TIMEOUT_PASSED flag * for the specified timeout. * Thanks to Bylos for catching this bug. */ const int state = _sync_fetch_and_and(&timeout_state[timeout], TIMEOUT_PASSED); /* Invalid timeout? */ if (!(state & TIMEOUT_USED)) return -1; /* Not armed? */ if (!(state & TIMEOUT_ARMED)) return -1; /* Return 1 if passed, 0 otherwise. */ return (state & TIMEOUT_PASSED) ? 1 : 0; } else { /* Invalid timeout number. */ return -1; } } int timeout_set(const double seconds) { struct timespec now, then; struct itimerspec when; double next; int timeout, i; /* Timeout must be in the future. */ if (seconds <= 0.0) return -1; /* Get current time, */ if (clock_gettime(CLOCK_REALTIME, &now)) return -1; /* and calculate when the timeout should fire. */ then = now; timespec_add(&then, seconds); /* Find an unused timeout. */ for (timeout = 0; timeout < TIMEOUTS; timeout++) if (!(__sync_fetch_and_or(&timeout_state[timeout], TIMEOUT_USED) & TIMEOUT_USED)) break; /* No unused timeouts? */ if (timeout >= TIMEOUTS) return -1; /* Clear all but TIMEOUT_USED from the state, */ __sync_and_and_fetch(&timeout_state[timeout], TIMEOUT_USED); /* update the timeout details, */ timeout_time[timeout] = then; /* and mark the timeout armable. */ __sync_or_and_fetch(&timeout_state[timeout], TIMEOUT_ARMED); /* How long till the next timeout? */ next = seconds; for (i = 0; i < TIMEOUTS; i++) if ((__sync_fetch_and_or(&timeout_state[i], 0) & (TIMEOUT_USED | TIMEOUT_ARMED | TIMEOUT_PASSED)) == (TIMEOUT_USED | TIMEOUT_ARMED)) { const double secs = timespec_diff(timeout_time[i], now); if (secs >= 0.0 && secs < next) next = secs; } /* Calculate duration when to fire the timeout next, */ timespec_set(&when.it_value, next); when.it_interval.tv_sec = 0; when.it_interval.tv_nsec = 0L; /* and arm the timer. */ if (timer_settime(timeout_timer, 0, &when, NULL)) { /* Failed. */ __sync_and_and_fetch(&timeout_state[timeout], 0); return -1; } /* Return the timeout number. */ return timeout; } static void timeout_signal_handler(int signum __attribute__((unused)), siginfo_t *info, void *context __attribute__((unused))) { struct timespec now; struct itimerspec when; int saved_errno, i; double next; /* Not a timer signal? */ if (!info || info->si_code != SI_TIMER) return; /* Save errno; some of the functions used may modify errno. */ saved_errno = errno; if (clock_gettime(CLOCK_REALTIME, &now)) { errno = saved_errno; return; } /* Assume no next timeout. */ next = -1.0; /* Check all timeouts that are used and armed, but not passed yet. */ for (i = 0; i < TIMEOUTS; i++) if ((__sync_or_and_fetch(&timeout_state[i], 0) & (TIMEOUT_USED | TIMEOUT_ARMED | TIMEOUT_PASSED)) == (TIMEOUT_USED | TIMEOUT_ARMED)) { const double seconds = timespec_diff(timeout_time[i], now); if (seconds <= 0.0) { /* timeout [i] fires! */ __sync_or_and_fetch(&timeout_state[i], TIMEOUT_PASSED); } else if (next <= 0.0 || seconds < next) { /* This is the soonest timeout in the future. */ next = seconds; } } /* Note: timespec_set() will set the time to zero if next <= 0.0, * which in turn will disarm the timer. * The timer is one-shot; it_interval == 0. */ timespec_set(&when.it_value, next); when.it_interval.tv_sec = 0; when.it_interval.tv_nsec = 0L; timer_settime(timeout_timer, 0, &when, NULL); /* Restore errno. */ errno = saved_errno; } int timeout_init(void) { struct sigaction act; struct sigevent evt; struct itimerspec arm; /* Install timeout_signal_handler. */ sigemptyset(&act.sa_mask); act.sa_sigaction = timeout_signal_handler; act.sa_flags = SA_SIGINFO; if (sigaction(TIMEOUT_SIGNAL, &act, NULL)) return errno; /* Create a timer that will signal to timeout_signal_handler. */ evt.sigev_notify = SIGEV_SIGNAL; evt.sigev_signo = TIMEOUT_SIGNAL; evt.sigev_value.sival_ptr = NULL; if (timer_create(CLOCK_REALTIME, &evt, &timeout_timer)) return errno; /* Disarm the timeout timer (for now). */ arm.it_value.tv_sec = 0; arm.it_value.tv_nsec = 0L; arm.it_interval.tv_sec = 0; arm.it_interval.tv_nsec = 0L; if (timer_settime(timeout_timer, 0, &arm, NULL)) return errno; return 0; } int timeout_done(void) { struct sigaction act; struct itimerspec arm; int errors = 0; /* Ignore the timeout signals. */ sigemptyset(&act.sa_mask); act.sa_handler = SIG_IGN; if (sigaction(TIMEOUT_SIGNAL, &act, NULL)) if (!errors) errors = errno; /* Disarm any current timeouts. */ arm.it_value.tv_sec = 0; arm.it_value.tv_nsec = 0L; arm.it_interval.tv_sec = 0; arm.it_interval.tv_nsec = 0; if (timer_settime(timeout_timer, 0, &arm, NULL)) if (!errors) errors = errno; /* Destroy the timer itself. */ if (timer_delete(timeout_timer)) if (!errors) errors = errno; /* If any errors occurred, set errno. */ if (errors) errno = errors; /* Return 0 if success, errno otherwise. */ return errors; } 

记住编译时要包含rt库,即使用gcc -W -Wall *source*.c -lrt -o *binary*进行编译。

这个想法是,主程序首先调用timeout_init()来安装所有必要的处理程序等等,并可以在退出之前调用timeout_done()来取消所有的处理程序(或fork()之后的子进程)。

要设置超时,请调用timeout_set(seconds) 。 返回值是一个超时描述符。 目前只有一个可以使用timeout_passed()检查的标志,但是超时信号的传递也会中断任何阻塞的I / O调用。 因此,您可以预期超时会中断任何阻塞的I / O调用。

如果你不想在超时时设置一个标志,你不能​​在信号处理程序中完成; 请记住,在信号处理程序中,您仅限于异步信号安全功能。 最简单的方法是在sigwaitinfo()上使用一个带有无限循环的独立线程,并在所有其他线程中阻塞TIMEOUT_SIGNAL信号。 这样,专用线程就能保证捕捉到信号,但同时不限于异步信号安全功能。 例如,它可以做更多的工作,甚至可以使用pthread_kill()向特定的线程发送信号。 (只要该信号具有一个处理程序,即使是具有空体的处理程序,其交付也将中断该线程中的任何阻塞I / O调用。

这里是一个简单的例子main()来使用超时。 这是愚蠢的,并依靠fgets()不重试(当一个信号中断),但它似乎工作。

 #include <string.h> #include <stdio.h> int main(void) { char buffer[1024], *line; int t1, t2, warned1; if (timeout_init()) { fprintf(stderr, "timeout_init(): %s.\n", strerror(errno)); return 1; } printf("You have five seconds to type something.\n"); t1 = timeout_set(2.5); warned1 = 0; t2 = timeout_set(5.0); line = NULL; while (1) { if (timeout_passed(t1)) { /* Print only the first time we notice. */ if (!warned1++) printf("\nTwo and a half seconds left, buddy.\n"); } if (timeout_passed(t2)) { printf("\nAw, just forget it, then.\n"); break; } line = fgets(buffer, sizeof buffer, stdin); if (line) { printf("\nOk, you typed: %s\n", line); break; } } /* The two timeouts are no longer needed. */ timeout_unset(t1); timeout_unset(t2); /* Note: 'line' is non-NULL if the user did type a line. */ if (timeout_done()) { fprintf(stderr, "timeout_done(): %s.\n", strerror(errno)); return 1; } return 0; } 

有用的阅读是时间(7)手册页。 注意,Linux还提供了timerfd_create(2)特定于Linux的系统调用 ,通常与poll(2) (或ppoll(2)或较旧的select(2)系统调用)一起使用。

如果你想使用信号,不要忘记仔细阅读信号(7)的手册页(编码信号处理程序有限制;你可能想要在你的信号处理程序中设置一个volatile sigatomic_t变量;你不应该做任何newdelete – 或mallocfree – 内存menagenment操作内部信号处理程序,其中只允许异步安全的函数调用)。

还要注意,面向事件的编程(如GUI应用程序)经常提供在其事件循环中管理定时器的方法(在Gtk中,在Qt中, libevent ,….)。