Need help applying timer in C in Linux

I want to create a timer in our C program so that it can print the variable after every 1 second.

Ca开发者_如何学运维n anybody help me in doing this?

Don't use busy waiting, because you've got 100% CPU utilization. You must use system function which turns process into sleeping mode for example select():

#include <stdio.h>
#include <sys/select.h>

void your_callback()
{
    printf("%s\n", __FUNCTION__);
}

int main()
{
    struct timeval t;

    while (1) {
        t.tv_sec = 1;
        t.tv_usec = 0;

        select(0, NULL, NULL, NULL, &t);

        your_callback();
    }

    return 0;
}

If all you are interested in doing is printing the value of a variable at a one second interval, using time(2) or clock(3) as suggested in the other answers might suffice. In general, I would not recommend these busy-waiting techniques.

If your program is more complex, I suggest you investigate using the alarm(2) or settimer(2) function to asynchronously deliver a signal to your application at a one second interval.

The following example uses select(2) to block indefinitely in order to minimize CPU usage associated with busy-waiting techniques. The blocking select() call is interrupted and returns when a signal is caught. In the case of the SIGALRM signal, the print_variable flag is set and the value of variable is printed.

Example 1: using alarm()

#include <signal.h>
#include <stdio.h>
#include <sys/select.h>
#include <unistd.h>

volatile unsigned int variable = 0;
volatile unsigned int print_variable = 0;

void alarm_handler(int signum)
{
    variable++;
    print_variable = 1;
    alarm(1);
}

int main()
{        
    signal(SIGALRM, alarm_handler);
    alarm(1);

    for (;;)
    {
        select(0, NULL, NULL, NULL, NULL);

        if (print_variable)
        {
            printf("Variable = %u\n", variable);
        }
    }
}

^{Note: Error checking was omitted from the above code for simplicity.}

^{A printf() function could have been called inside the SIGALRM handler, but calling non-reentrant functions in a signal handler is generally discouraged.}

A timeout of one second can also be passed to select(), but if it were interrupted by any signal, additional logic is necessary to ensure that the remainder of the one second timeout is honored. Fortunately on Linux, select() modifies the timeout value to reflect the amount of time not slept. This allows interruption cases to be detected followed by subsequent call(s) select() to complete the timeout.

Example 2: using select()

#include <errno.h>
#include <stdio.h>
#include <sys/select.h>

volatile unsigned int variable = 0;

int main()
{
    struct timeval tv;
    int val;

    for (;;)
    {
        tv.tv_sec = 1;
        tv.tv_usec = 0;

        do
        {
            val = select(0, NULL, NULL, NULL, &tv);
        } while (val != 0 && errno == EINTR);

        printf("Variable = %u\n", ++variable);
    }
}

If you want only second precision. Use time(0) which returns current time if time.h is included.

update: Adding simple example which prints 10 in every second during 20 seconds:

#include <time.h>
#include <stdio.h>

int main()
{
    int a = 10;
    int num = 20;
    int c = time(0);
    while(n--)
    {
        printf("%d\n", a);
        while(!(time(0) - c));
        c = time(0);
    }
    return 0;
}

use time(0) see this example

/* timer.c */ 
#include <stdio.h> 
#include <time.h> 

void delay_sec( int seconds ){ 
    clock_t endwait; 
    endwait = clock () + seconds * CLOCKS_PER_SEC; 
    while (clock() < endwait) {} 
} 

int main (void){ 
    time_t rawtime, ini_time, now; 
    struct tm *ptm; 

    time ( &ini_time ); 
    for(;;){ 
        time ( &rawtime ); 
        //ptm = gmtime ( &rawtime ); 
        //printf ("%2d:%02d:%02d\n", ptm_2->tm_hour, ptm_2->tm_min, ptm_2->tm_sec); 
        now = rawtime - ini_time; 
        ptm = gmtime ( &now ); 
        printf ("%2d:%02d:%02d\n", ptm->tm_hour, ptm->tm_min, ptm->tm_sec); 
        delay_sec(1); 
    } 
    return 0; 
}  

I believe you know 1000 Milliseconds equals to 1 Second.

#include <stdio.h>  
#include <time.h>
#define mydelay 1000

void delay(int mseconds)
{
    clock_t wait = mseconds + clock();
    while (wait > clock());
}

int main()  
{  
   int i=100;
   while(1)
   {
           printf("%d\n",i);
           delay(mydelay);
   }              
   return 0;  
}

A simple example which prints the value of the variable a for every 1 sec:

#include<stdio.h>

void main(void)
{
  int a = 10;
  while(a--)
  {
    printf("Value of a = %d\n", a);
    sleep(1);  
  }

}

Output:

Value of a = 9
...
value of a = 0