4

The task is to execute a function (say Processfunction()) every x (say x=10) seconds.

With below code, I'm able to call Processfunction() every x seconds.

Question: How to handle the case where the function takes more than 10 seconds to finish execution?

One way would be to have a flag to indicate the end of Processfunction() execution and check for it before calling Processfunction(). Is there a better way to do this ? 

#include <pthread.h>
#include <unistd.h> // for sleep() and usleep()

void *timerthread(void *timer_parms) {  

  struct itimerspec new_value;
  int max_exp, fd;
  struct timespec now;
  uint64_t exp;
  ssize_t s;

  struct timer_params *p =(struct timer_params*)timer_parms;

  printf("starttimer Start\n");
  /* Create a CLOCK_REALTIME absolute timer with initial
     expiration and interval as specified in command line */
  if (clock_gettime(CLOCK_REALTIME, &now) == -1)
    handle_error("clock_gettime");

  new_value.it_value.tv_sec = now.tv_sec;
  new_value.it_value.tv_nsec = now.tv_nsec + p->tv_nsec;
  new_value.it_interval.tv_sec = p->tv_sec;
  new_value.it_interval.tv_nsec = p->tv_nsec;
  //max_exp = 5; //No of times

  fd = timerfd_create( CLOCK_REALTIME , 0);
  if (fd == -1)
    handle_error("timerfd_create");

  if (timerfd_settime(fd, TFD_TIMER_ABSTIME, &new_value, NULL) == -1)
    handle_error("timerfd_settime");

  printf("timer started\n");

  while(1) // keep checking
  {
    s = read(fd, &exp, sizeof(uint64_t));
    if (s != sizeof(uint64_t))
      handle_error("read");
    Processfunction(); // Say after X seconds call this function
  }
  return NULL;
}

int main() {

  struct timer_params timer_params_obj;
  int res;void *thread_result;
  timer_params_obj.tv_sec = 10; 
  //timer_params_obj.tv_nsec = 10000000  ; //10ms
  timer_params_obj.tv_nsec = 0  ; 

  pthread_t pt;
  pthread_create(&pt, NULL, timerthread, &timer_params_obj);
  // thread is running and will call Processfunction() every 10 sec
}
4

2 回答 2

6

为什么你需要一个计时器呢？

您可以根据经过时间与所需间隔持续时间的关系测量执行时间并进入睡眠状态。

例子：

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

int main() {
    srand(1);
    for (;;) {
        double interval = 10; /* seconds */

        /* start time */
        time_t start = time(NULL);

        /* do something */
        int duration = rand() % 13;
        printf("%2d seconds of work started at %s", duration, ctime(&start));
        sleep(duration);

        /* end time */
        time_t end = time(NULL);

        /* compute remaining time to sleep and sleep */
        double elapsed = difftime(end, start);
        int seconds_to_sleep = (int)(interval - elapsed);
        if (seconds_to_sleep > 0) { /* don't sleep if we're already late */
            sleep(seconds_to_sleep);
        }
    }
    return 0;
}

输出：

$ gcc test.c && ./a.out
 0 seconds of work started at Sun Mar 17 21:20:28 2013
 9 seconds of work started at Sun Mar 17 21:20:38 2013
11 seconds of work started at Sun Mar 17 21:20:48 2013
 4 seconds of work started at Sun Mar 17 21:20:59 2013
 1 seconds of work started at Sun Mar 17 21:21:09 2013
^C
于 2013-03-17T20:25:13.777 回答
1

我有一个几乎相同的用例，除了我需要它是跨平台的 C++11 并且需要同时执行其他任务而不是睡觉。这是我的代码，以防它对某人有用：

// TimeT.h - Calls the passed function if the minimum time interval has elapsed
#ifndef TIME_T_H_
#define TIME_T_H_

#include <chrono>

/// Tracks the time since execution() was called, and only
/// Calls the passed function if the minimum time interval has elapsed
/// @see https://stackoverflow.com/questions/2808398/easily-measure-elapsed-time for the code I based this on
template<typename TimeT = std::chrono::milliseconds>
struct periodic
{
    periodic(TimeT duration = TimeT(1))
        : start(std::chrono::system_clock::now())
        , period_duration(duration)
        , previous_duration(TimeT::zero())
    {};

    template<typename F, typename ...Args>
    TimeT execution(F func, Args&&... args)
    {
        auto duration = std::chrono::duration_cast<TimeT>
                            (std::chrono::system_clock::now() - start);
        if (duration > previous_duration + period_duration)
        {
            std::forward<decltype(func)>(func)(std::forward<Args>(args)...);
            previous_duration = duration;
        }
        return duration;
    }

    std::chrono::time_point<std::chrono::system_clock> start;
    // The minimum duration to wait before the function can be called again
    TimeT period_duration;
    // The duration between startup and the last time the function was called
    TimeT previous_duration;
};

#endif // TIME_T_H_

这是一个使用它的例子：

#include "TimeT.h"    

#include <iostream>
#include <thread>

int main(int argc, char* argv[])
{
     periodic<> callIfMinPeriodPassed(std::chrono::milliseconds(1));
     std::size_t num_periods;

     while(true)
     {
          callIfMinPeriodPassed.execution( [&num_periods]()
          {
                  std::cout << ++num_periods << "timesteps have passed\n"
          });
          // do other stuff here, this example will work
          // but spins at 100% CPU without the sleep
          std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }
}

这个实现是基于这个关于测量经过时间的stackoverflow问题的修改。

于 2015-08-06T21:15:26.917 回答