Exécuter une méthode, toutes les x secondes en C

Est-il un exemple de travail d'une minuterie qui exécute une fonction toutes les x secondes à l'aide de C.

J'apprécierais un exemple de code qui fonctionne.

man 3 sleep: Il suffit d'écrire une boucle qui 1) ne quelque chose, 2) dort "n" secondes

OriginalL'auteur Firre | 2012-12-17

  1. 13

    Vous pourriez générer un nouveau thread:

    void *threadproc(void *arg)
{
    while(!done)
    {
        sleep(delay_in_seconds);
        call_function();
    }
    return 0;
}
...
pthread_t tid;
pthread_create(&tid, NULL, &threadproc, NULL);

    Ou, vous pouvez définir une alarme avec alarme(2) ou setitimer(2):

    void on_alarm(int signum)
{
    call_function();
    if(!done)
        alarm(delay_in_seconds);  //Reschedule alarm
}
...
//Setup on_alarm as a signal handler for the SIGALRM signal
struct sigaction act;
act.sa_handler = &on_alarm;
act.sa_mask = 0;
act.sa_flags = SA_RESTART;  //Restart interrupted system calls
sigaction(SIGALRM, &act, NULL);

alarm(delay_in_seconds);  //Setup initial alarm

    Bien sûr, ces deux méthodes ont le problème que la fonction que vous appelez doit périodiquement être thread-safe.

    Le signal de la méthode est particulièrement dangereuse, car elle doit aussi être async-sûr, ce qui est très dur à faire, même une chose aussi simple que printf est dangereux parce que les printf peut allouer de la mémoire, et si le SIGALRM interrompu un appel à malloc, vous êtes en difficulté, parce que malloc n'est pas réentrant. Donc, je ne recommanderais pas le signal de la méthode, à moins que tous vous avez à faire est de définir un indicateur dans le gestionnaire de signal qui plus tard devient vérifié par une autre fonction, ce qui vous fait revenir au même endroit que la version letée.

    Le problème est que j'utilise la SDL et parce que, quand j'appuie sur le bouton de sortie, il faudra patienter jusqu'à ce que la boucle se fait (qui gèle aussi à la demande). Ex. for(i = 0; i < 5; i++) { sleep(1) }

    OriginalL'auteur Adam Rosenfield

  2. 6

    Il y a de divers legs de façons de le faire à l'aide de compteurs d'intervalle et de signaux, mais je vais présenter deux approches modernes:

    À l'aide de POSIX minuteries

    POSIX timer_create fonction crée une minuterie qui peut être configuré pour fournir une ponctuelle ou périodique de notification lors de l'expiration de la minuterie. Lors de la création de la minuterie, vous pouvez demander la livraison par l'intermédiaire d'un signal ou dans un nouveau thread. Depuis l'utilisation de signaux correctement est compliqué (il y a des règles strictes sur ce que vous pouvez et ne pouvez pas le faire à partir d'un gestionnaire de signal, et de briser les règles souvent "semble fonctionner", jusqu'à ce que vous obtenez malheureux), je recommande l'utilisation de thread basée à la livraison.

    Rouler votre propre compteur avec un fil

    C'est vraiment aussi facile qu'il y paraît. De faire un nouveau thread qui va dans une boucle de dormir et de faire ce que vous devez faire à chaque fois que l'heure souhaitée s'est écoulé.

    OriginalL'auteur R..

  3. 0

    De l'OMI, dans ce cas, vous pouvez utiliser gettimeofday() dans l'algorithme comme:
    l'utilisation d'une telle while(1) qui compte de la différence de temps entre l'heure actuelle et last_execution_time, à chaque fois que la différence atteindre les 1 secondes, mise à jour de la last_execution_time et d'appeler la fonction qui censé fonctionner dans toutes les 1 seconde.

    #include <stdio.h>
#include <sys/time.h>
#DEFINE DESIRED_INTERVAL 1  //1 second
int get_tv_cur_minus_given(struct timeval *tv, struct timeval *tp_given, int *sign)
{
struct timeval tp_cur;
gettimeofday(&tp_cur,NULL);
tv->tv_sec  = tp_cur.tv_sec - tp_given->tv_sec;
tv->tv_usec = tp_cur.tv_usec - tp_given->tv_usec;
if(tv->tv_sec > 0) {
*sign = 1;
if(tv->tv_usec < 0) {
tv->tv_sec--;
tv->tv_usec = 1000000 + tv->tv_usec;
}
}else
if(tv->tv_sec == 0) {
if(tv->tv_usec == 0)
*sign = 0;
else
if(tv->tv_usec < 0) {
*sign = -1;
tv->tv_usec *= -1;
}else
*sign = 1;
}else {
*sign = -1;
if(tv->tv_usec > 0) {
tv->tv_sec++;
tv->tv_usec = 1000000 - tv->tv_usec;
}else
if(tv->tv_usec < 0)
tv->tv_usec *= -1;
return 0;
}
}
int main()
{
struct timeval      tv_last_run;
struct timeval  tv_diff;
int sign;
while(true)
{
get_tv_cur_minus_given(&tv_diff, &tv_last_run, &sign);
if(tv_diff.tv_sec > DESIRED_INTERVAL)
{
gettimeofday(&tv_last_run,NULL);
printf("\ncall the func here");
}
}
return 0;
}

    Dans le cas où vous avez besoin de thread différent de thread principal, déplacer les lignes de l'intérieur() un pointeur de fonction et le passer à travers pthread_create fonction, par exemple :

    void *threadproc(void *arg)
{
while(1)
{
//put the same lines as inside main() function in above code snippet. .
}
}
pthread_create(&tid, NULL, &threadproc, NULL);

    OriginalL'auteur Asmoro Glenmore