boost asio timer,linux time and timer

boost 定时器有同步和异步两种：
同步定时器

编译-lboost_system

运行export  LD_LIBRARY_PATH=/usr/local/include/boost_1_57_0-x86/__INSTALL/lib

#include <iostream>
#include <boost/asio.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

using namespace boost;
using namespace boost::asio;
int main() {

io_service ios;
deadline_timer t(ios,posix_time::seconds(2));

t.wait();

return 0;
}

异步定时器

编译-lboost_system

运行export  LD_LIBRARY_PATH=/usr/local/include/boost_1_57_0-x86/__INSTALL/lib

#include <iostream>
#include <boost/asio.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

using namespace boost;
using namespace boost::asio;

void call_func1(const  boost::system::error_code& e)
{

printf("%s\n",e.message().c_str());//Success
}

int main() {

io_service ios;
deadline_timer t(ios,posix_time::seconds(2));

t.async_wait(call_func1);
ios.run();

return 0;
}

ff

//
// timer.cpp
// ~~~~~~~~~
//
// Copyright (c) 2003-2014 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) //

#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

class printer
{
public:
printer(boost::asio::io_service& io)
: timer_(io, boost::posix_time::seconds(1)),
count_(0)
{
timer_.async_wait(boost::bind(&printer::print, this));
}

~printer()
{
std::cout << "Final count is " << count_ << "\n";
}

void print()
{
if (count_ < 5)
{
std::cout << count_ << "\n";
++count_;

timer_.expires_at(timer_.expires_at() + boost::posix_time::seconds(1));
timer_.async_wait(boost::bind(&printer::print, this));
}
}

private:
boost::asio::deadline_timer timer_;
int count_;
};
int main()
{
boost::asio::io_service io;
printer p(io);
io.run();

return 0;
}

#include <iostream>
#include <boost/ref.hpp>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
using namespace boost;
using namespace boost::asio;

void call_func1(io_service &ios)
{
try {
std::cout << "call_func1" << std::endl;

} catch (std::exception &e) {
std::cout << e.what() << std::endl;
}
}

void call_func2()
{
try {
std::cout << "call_func2" << std::endl;

} catch (std::exception &e) {
std::cout << e.what() << std::endl;
}
}

class a_timer
{
private:
int count, count_max;
boost::function<void()> f;
boost::asio::deadline_timer t;

public:
template<typename F>
a_timer(io_service &ios, int x, F func): f(func), count_max(x), count(0),
t(ios, boost::posix_time::millisec(1000)) {
t.async_wait(boost::bind(&a_timer::call_func, this, boost::asio::placeholders::error));
}

void call_func(const boost::system::error_code&)
{
if (count >= count_max) {
return;
}
++count;
f();
t.expires_at(t.expires_at() + boost::posix_time::millisec(500));
t.async_wait(boost::bind(&a_timer::call_func, this, boost::asio::placeholders::error));
}

};

int main()
{
io_service ios;
a_timer at1(ios, 2, boost::bind(call_func1, boost::ref(ios)));
a_timer at2(ios,3,call_func2);

ios.run();
}

另外，linux应用层的系统调用2和c库3的定时器函数总结如下：

计时函数@REF1

time(2) / time_t （秒）
ftime(3) / struct timeb （毫秒）
gettimeofday(2) / struct timeval （微秒）
clock_gettime(2) / struct timespec （纳秒）
gmtime / localtime / timegm / mktime / strftime / struct tm （这些与当前时间无关）

定时函数

sleep
alarm
usleep
nanosleep
clock_nanosleep
getitimer / setitimer
timer_create / timer_settime / timer_gettime / timer_delete
timerfd_create / timerfd_gettime / timerfd_settime

alarm函数：

alarm超时信号会终止主线程的sleep函数

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <pthread.h>

using namespace std;

void my_alarm_handler(int a){
cout<<" my_alarm_handler"<<endl;
alarm(3);//更改为2秒调用一次Timer
}
static void * thread_start1(void *arg)
{
while(1)
{
int iLeft=sleep(6);
cout<<"thread1,sleep,iLeft= "<<iLeft<<endl;
}
}
static void * thread_start2(void *arg)
{
while(1)
{
int iLeft=sleep(6);
cout<<"thread2,sleep,iLeft= "<<iLeft<<endl;
}
}
int main(){
pthread_t t1;
pthread_create(&t1, NULL, &thread_start1, NULL);
pthread_t t2;
pthread_create(&t2, NULL, &thread_start2, NULL);

cout << "1" <<endl;
signal( SIGALRM, my_alarm_handler);
cout << "2" <<endl;
alarm(3);
cout << "3" <<endl;

while(1)
{
int iLeft=sleep(6);
cout<<"main,sleep,iLeft= "<<iLeft<<endl;
}
return 0;
}

# ./ab 
1
2
3

 my_alarm_handler
main,sleep,iLeft= 3

 my_alarm_handler
main,sleep,iLeft= 3
thread2,sleep,iLeft= 0
thread1,sleep,iLeft= 0

 my_alarm_handler
main,sleep,iLeft= 3

thread2,sleep,iLeft= 0
thread1,sleep,iLeft= 0
 my_alarm_handler
main,sleep,iLeft= 3

可见，

main thread的sleep会被alarm中断掉而返回，每次都执行sleep了一半

其他thread的sleep函数则正常

timer_create / timer_settime / timer_gettime / timer_delete

#include <sys/timerfd.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>        /* Definition of uint64_t */
#include <time.h>

#define handle_error(msg) \
do { perror(msg); exit(EXIT_FAILURE); } while (0)

static void
print_elapsed_time(void)
{
static struct timespec start;
struct timespec curr;
static int first_call = 1;
int secs, nsecs;

if (first_call) {
first_call = 0;
if (clock_gettime(CLOCK_MONOTONIC, &start) == -1)
handle_error("clock_gettime");
}

if (clock_gettime(CLOCK_MONOTONIC, &curr) == -1)
handle_error("clock_gettime");

secs = curr.tv_sec - start.tv_sec;
nsecs = curr.tv_nsec - start.tv_nsec;
if (nsecs < 0) {
secs--;
nsecs += 1000000000;
}
printf("%d.%03d: ", secs, (nsecs + 500000) / 1000000);
}

int
main(int argc, char *argv[])
{
struct itimerspec new_value;
int max_exp, fd;
struct timespec now;
uint64_t exp, tot_exp;
ssize_t s;

if ((argc != 2) && (argc != 4)) {
fprintf(stderr, "%s init-secs [interval-secs max-exp]\n",
argv[0]);
exit(EXIT_FAILURE);
}

if (clock_gettime(CLOCK_REALTIME, &now) == -1)
handle_error("clock_gettime");

/* Create a CLOCK_REALTIME absolute timer with initial
expiration and interval as specified in command line */

new_value.it_value.tv_sec = now.tv_sec + atoi(argv[1]);
new_value.it_value.tv_nsec = now.tv_nsec;
if (argc == 2) {
new_value.it_interval.tv_sec = 0;
max_exp = 1;
} else {
new_value.it_interval.tv_sec = atoi(argv[2]);
max_exp = atoi(argv[3]);
}
new_value.it_interval.tv_nsec = 0;

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");

print_elapsed_time();
printf("timer started\n");

for (tot_exp = 0; tot_exp < max_exp;) {
s = read(fd, &exp, sizeof(uint64_t));
if (s != sizeof(uint64_t))
handle_error("read");

tot_exp += exp;
print_elapsed_time();
printf("read: %llu; total=%llu\n",
(unsigned long long) exp,
(unsigned long long) tot_exp);
}

exit(EXIT_SUCCESS);
}

./ab 3 1 6
0.000: timer started
3.000: read: 1; total=1
4.000: read: 1; total=2
5.000: read: 1; total=3
6.000: read: 1; total=4
7.001: read: 1; total=5
8.001: read: 1; total=6

----------------------------------------------------------

@REF1
http://blog.csdn.net/Solstice/article/details/6173563
陈硕