linux下时间操作1

本文是对我之前写的文章：C++时间操作 的更深入补充。之前那个文章就是一个快速入门的东西，后面力图把一些更深入的细节补充完整。

时间分类的基本介绍

在介绍一些时间相关的操作函数之前，先来介绍一下linux/UNIX下面的几种常用的时间。

在内核中维护了以下的时间：

从大类别上分类的话，主要分为硬件时钟与系统时钟。硬件时钟是指主机板上的时钟设备，也就是通常可在BIOS画面设定的时钟。系统时钟则是指kernel中 的时钟。所有Linux相关指令与函数都是读取系统时钟的设定。因为存在两种不同的时钟，那么它们之间就会存在差异。根据不同参数设置，hwclock命令既可以将硬件时钟同步到系统时钟，也可以将系统时钟同步到硬件时钟。可以通过hwclock命令来读取或设置硬件时钟。

-r, --show         读取并打印硬件时钟（read hardware clock and print result ）

-s, --hctosys      将硬件时钟同步到系统时钟（set the system time from the hardware clock
）

-w, --systohc     将系统时钟同步到硬件时钟（set the hardware clock to the current system time
）

1、硬件时钟：

（1）RTC时间

在PC中，RTC时间又叫CMOS时间，它通常由一个专门的计时硬件来实现，软件可以读取该硬件来获得年月日、时分秒等时间信息，而在嵌入式系统中，有使用专门的RTC芯片，也有直接把RTC集成到Soc芯片中，读取Soc中的某个寄存器即可获取当前时间信息。一般来说，RTC是一种可持续计时的，也就是说，不管系统是否上电，RTC中的时间信息都不会丢失，计时会一直持续进行，硬件上通常使用一个后备电池对RTC硬件进行单独的供电。因为RTC硬件的多样性，开发者需要为每种RTC时钟硬件提供相应的驱动程序，内核和用户空间通过驱动程序访问RTC硬件来获取或设置时间信息。

 int rtc_test(void)
 {
     struct rtc_time rtc;
     int fd = -;
     int ret = -;
     fd = open("/dev/rtc0", O_RDWR);
     if (fd < ){
         return -;
     }
     ret = ioctl(fd, RTC_RD_TIME, &rtc);
     if (ret < ){
         return -;
     }
     printf("\nCurrentRTC data/time is %d-%d-%d, %02d:%02d:%02d.\n", rtc.tm_mday, rtc.tm_mon + ,
     rtc.tm_year + , rtc.tm_hour, rtc.tm_min, rtc.tm_sec);
     ret = ioctl(fd, RTC_SET_TIME, &rtc);
     if (ret < ){
         return -;
     }
     return ;
 }

或者使用上面提到的hwclock命令来搞

 system("hwclock -w");

2、系统时钟：

（1）wall时间

wall时间也称为xtime，取决于用于对xtime计时的clocksource，它的精度甚至可以达到纳秒级别。因为xtime实际上是一个内存中的变量，它的访问速度非常快，内核大部分时间都是使用xtime来获得当前时间信息。xtime记录的是自Epoch（1970-01-01 00:00:00 UTC）到当前时刻所经历的纳秒数。

（2）monotonic时间

该时间自系统开机后就一直单调地增加，它不像xtime可以因用户的调整时间而产生跳变，不过该时间不计算系统休眠的时间，也就是说，系统休眠时，monotoic时间不会递增。

（3）raw monotonic时间

该时间与monotonic时间类似，也是单调递增的时间，唯一的不同是：raw monotonic time“更纯净”，不会受到NTP时间调整的影响，它代表着系统独立时钟硬件对时间的统计。

（4）boot时间

与monotonic时间相同，不过会累加上系统休眠的时间，它代表着系统上电后的总时间。

时间种类	精度（统计单位）	访问速度	累计休眠时间	受NTP调整的影响
RTC	低	慢	Yes	Yes
xtime	高	快	Yes	Yes
monotonic	高	快	No	Yes
raw monotonic	高	快	No	No
boot time	高	快	Yes	Yes

上面介绍的系统时间其实在linux系统调用的clock_gettime()函数可以充分体现出来。

 int clock_gettime(clockid_t clk_id, struct timespec *tp);

在这里我们就简单的看一下，后面再详细介绍时间相关的函数。所以这里就只关注第一个参数clk_id，它支持的值就对应了上面我们提到的系统时间，而且比提到的稍微还多了一些时间支持。下面引用一下man手册里面对于clk_id的选项：

CLOCK_REALTIME：系统实时时间，从Epoch计时，可以被用户更改以及adjtime和NTP影响。
CLOCK_REALTIME_COARSE：系统实时时间，比起CLOCK_REALTIME有更快的获取速度，更低一些的精确度。(since Linux 2.6.32; Linux-specific)
CLOCK_MONOTONIC：从系统启动这一刻开始计时，即使系统时间被用户改变，也不受影响。系统休眠时不会计时。受adjtime和NTP影响。
CLOCK_MONOTONIC_COARSE：如同CLOCK_MONOTONIC，但有更快的获取速度和更低一些的精确度。受NTP影响。(since Linux 2.6.32; Linux-specific)
CLOCK_MONOTONIC_RAW：与CLOCK_MONOTONIC一样，系统开启时计时，不受NTP和adjtime影响。(since Linux 2.6.28; Linux-specific)
CLOCK_BOOTTIME: 从系统启动这一刻开始计时，包括休眠时间，受到settimeofday的影响。(since Linux 2.6.39; Linux-specific)
CLOCK_PROCESS_CPUTIME_ID: 本进程开始到此刻调用的时间。
CLOCK_THREAD_CPUTIME_ID: 本线程开始到此刻调用的时间。

内核新增的这些选项在以前不支持的时候只能通过某些系统调用syscall去搞，比如syscall(SYS_clock_gettime, CLOCK_MONOTONIC_RAW, &monotonic_time)。

update 2017-12-19：

上面的这些参数实际上可以从linux的uapi中（http://elixir.free-electrons.com/linux/latest/source/include/uapi/linux/time.h）找到出处：

 /*
  * The IDs of the various system clocks (for POSIX.1b interval timers):
  */
 #define CLOCK_REALTIME            0
 #define CLOCK_MONOTONIC            1
 #define CLOCK_PROCESS_CPUTIME_ID    2
 #define CLOCK_THREAD_CPUTIME_ID        3
 #define CLOCK_MONOTONIC_RAW        4
 #define CLOCK_REALTIME_COARSE        5
 #define CLOCK_MONOTONIC_COARSE        6
 #define CLOCK_BOOTTIME            7
 #define CLOCK_REALTIME_ALARM        8
 #define CLOCK_BOOTTIME_ALARM        9

为了使开发的时间库可以通用，还是需要用syscall先去判断一下，而不要用clock_gettime函数直接去搞

 clockid_t get_monotonic_clockid() {
     const clockid_t MY_CLOCK_MONOTONIC_RAW = ;

     timespec ts;
     if ( == syscall(SYS_clock_gettime, MY_CLOCK_MONOTONIC_RAW, &ts)) {
         return MY_CLOCK_MONOTONIC_RAW;
     }
     return CLOCK_MONOTONIC;
 }

时间相关的结构体说明

在我们介绍时间相关的那一坨函数之前，先来看看相应的一些结构体再说。

1、time_t

在time.h中的定义如下：

 typedef __time_t time_t;

然后再看bits/types.h中的定义：

 __STD_TYPE __TIME_T_TYPE __time_t;  /* Seconds since the Epoch.  */

再看bits/typesizes.h中的定义：

 #define __TIME_T_TYPE               __SLONGWORD_TYPE

最后在bits/types.h中看到：

 #define __SLONGWORD_TYPE       long int

绕了一大圈其实就是long int类型……

2、timeval

在bits/time.h中的定义如下：

 /* A time value that is accurate to the nearest
    microsecond but also has a range of years.  */
 struct timeval
   {
     __time_t tv_sec;        /* Seconds.  */
     __suseconds_t tv_usec;  /* Microseconds.  */
   }; 

上面的__suseconds_t用追__time_t的方法追进去其实也是long int类型……

3、timespec

在time.h中的定义如下：

 /* POSIX.1b structure for a time value.  This is like a `struct timeval' but
    has nanoseconds instead of microseconds.  */
 struct timespec
   {
     __time_t tv_sec;        /* Seconds.  */
     long int tv_nsec;       /* Nanoseconds.  */
   };  

其实有了上面介绍的3个类型，我们可以对获取时间的函数做出一个取舍了，这个我们后面再说。

4、tm

在time.h中的定义如下：

 struct tm
 {
   int tm_sec;           /* Seconds. [0-60] (1 leap second) */
   int tm_min;           /* Minutes. [0-59] */
   int tm_hour;          /* Hours.   [0-23] */
   int tm_mday;          /* Day.     [1-31] */
   int tm_mon;           /* Month.   [0-11] */
   int tm_year;          /* Year - 1900.  */
   int tm_wday;          /* Day of week. [0-6] */
   int tm_yday;          /* Days in year.[0-365] */
   int tm_isdst;         /* DST.     [-1/0/1]*/

 #ifdef  __USE_BSD
   long int tm_gmtoff;       /* Seconds east of UTC.  */
   __const char *tm_zone;    /* Timezone abbreviation.  */
 #else
   long int __tm_gmtoff;     /* Seconds east of UTC.  */
   __const char *__tm_zone;  /* Timezone abbreviation.  */
 #endif
 };

好了，下面可以来看具体的函数了。注意编译的时候都要加上-lrt选项。

时间获取函数

1、time

 time_t time(time_t*tloc);

需要包含头文件：<time.h>

返回的是自Epoch时间以来的秒数。

例子：

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

 int main(int argc, char* argv[])
 {
      time_t t = time(NULL);
      printf("time: %d\n", static_cast<int>(t));

      return ;
 }

运行结果：

time: 1513419614

2、gettimeofday

 int gettimeofday(struct timeval* restrict tp, void* restrict tzp);

需要包含头文件：<sys/time.h>

其中第2个参数tzp的唯一合法值是NULL，其他值将产生不确定的结果。某些平台支持用tzp说明时区，但这完全依实现而定，Single UNIX Specification对此并没有定义。

因为返回的值存于结构体timeval中，所以是时间表示为秒和微秒。

例子：

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

 int main(int argc, char* argv[])
 {
      timeval tp;
      int ret = gettimeofday(&tp, NULL);
      printf("ret: %d\t sec: %d\t usec: %d\n", ret, tp.tv_sec, tp.tv_usec);

      return ;
 }

运行结果：

ret: 0   sec: 1513418627         usec: 881813

3、clock_gettime

 int clock_gettime(clockid_t clk_id, struct timespec* tp);

需要包含头文件：<sys/time.h>

里面关于第1个参数已经在上面详细介绍过了，这里就不说了。

因为返回的值存于结构体timespec中，所以是时间表示为秒和纳秒。

例子：

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

 int main()
 {

     struct timespec time1 = {, };  

     clock_gettime(CLOCK_REALTIME, &time1);
     printf("CLOCK_REALTIME: %d, %d\n", time1.tv_sec, time1.tv_nsec);  

     clock_gettime(CLOCK_REALTIME_COARSE, &time1);
     printf("CLOCK_REALTIME_COARSE: %d, %d\n", time1.tv_sec, time1.tv_nsec);  

     clock_gettime(CLOCK_MONOTONIC, &time1);
     printf("CLOCK_MONOTONIC: %d, %d\n", time1.tv_sec, time1.tv_nsec);  

     clock_gettime(CLOCK_MONOTONIC_COARSE, &time1);
     printf("CLOCK_MONOTONIC_COARSE: %d, %d\n", time1.tv_sec, time1.tv_nsec);  

     clock_gettime(CLOCK_MONOTONIC_RAW, &time1);
     printf("CLOCK_MONOTONIC_RAW: %d, %d\n", time1.tv_sec, time1.tv_nsec);  

     clock_gettime(CLOCK_BOOTTIME, &time1);
     printf("CLOCK_BOOTTIME: %d, %d\n", time1.tv_sec, time1.tv_nsec);  

     clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time1);
     printf("CLOCK_PROCESS_CPUTIME_ID: %d, %d\n", time1.tv_sec, time1.tv_nsec);  

     clock_gettime(CLOCK_THREAD_CPUTIME_ID, &time1);
     printf("CLOCK_THREAD_CPUTIME_ID: %d, %d\n", time1.tv_sec, time1.tv_nsec);  

     return ;
 }

运行结果：

CLOCK_REALTIME: 1513420159, 235041261
CLOCK_REALTIME_COARSE: 1513420159, 234034596
CLOCK_MONOTONIC: 39739363, 412544528
CLOCK_MONOTONIC_COARSE: 39739363, 411488462
CLOCK_MONOTONIC_RAW: 39739427, 821184328
CLOCK_BOOTTIME: 39739363, 412569480
CLOCK_PROCESS_CPUTIME_ID: 0, 1418885
CLOCK_THREAD_CPUTIME_ID: 0, 1423199

综合上面的分析，在计时的时候，只使用 gettimeofday 来获取当前时间，主要原因如下：

（1）time 的精度太低，ftime 已被废弃，clock_gettime 精度最高，但是它系统调用的开销比 gettimeofday 大。

（2）在 x86-64 平台上，gettimeofday 不是系统调用，而是在用户态实现的（搜 vsyscall），没有上下文切换和陷入内核的开销。

（3）gettimeofday 的分辨率 (resolution) 是 1 微秒，足以满足日常计时的需要。

不过在使用gettimeofday的时候有个坑是需要注意的，那就是用gettimeofday取毫秒会有溢出的问题。

 inline long getCurrentTime()
 {
     struct timeval tv;
     gettimeofday(&tv, NULL);
     return tv.tv_sec *  + tv.tv_usec / ;
 }

这样写的话在32位机器上是有坑的，因为tv.tv_sec * 1000后会溢出的。比如上面gettimeofday的例子中我们获取的值为1,513,418,627，乘以1000为1,513,418,627,000，早就远大于long在32位的机器上的范围为−2,147,483,648 ~ 2,147,483,647了。那么解决这个问题需要把long类型转换为long long，或者不支持long long类型的时候转为double。

 inline long long getCurrentTime()
 {
     struct timeval tv;
     gettimeofday(&tv, NULL);
     long long ms = tv.tv_sec;
     return ms *  + tv.tv_usec / ;
 }

这就完美了。解决完这个bug，不禁想到当unix时间戳到了2,147,483,647会是怎么办。这个问题早就有人考虑到了，叫做2038年问题。也就是到了2038年1月19日3时14分07秒后，如果在32位设备上用long类型再表示unix时间戳就溢出了。

溢出

时间打印函数

有很多这种函数，直接都写在一起得了。

 char* asctime(const struct tm* tm);
 char* asctime_r(const struct tm* tm, char* buf); // buf: 26 bytes at least

 char* ctime(const time_t* timep);
 char* ctime_r(const time_t* timep, char* buf);   // buf: 26 bytes at least

 struct tm* gmtime(const time_t* timep);
 struct tm* gmtime_r(const time_t* timep, struct tm* result);

 struct tm* localtime(const time_t* timep);
 struct tm* localtime_r(const time_t* timep, struct tm* result);

 time_t mktime(struct tm* tm);

需要包含头文件：<time.h>

asctime/asctime_r      : 把tm所表示的日期和时间转为字符串, 且会自动转为本地时区
ctime/ctime_r          : 把日期和时间转为字符串
gmtime/gmtime_r        : 把time_t转换为tm，未经时区转换
localtime/localtime_r  : 把time_t转换为tm，转为本地时区
mktime                 : 将tm转换为time_t，UTC

例子：

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

 static void ShowTM(const char* desc, const tm* t)
 {
      printf("%s:\n", desc);
      printf("%d-%02d-%02d %02d:%02d:%02d\n",
                     t->tm_year + , t->tm_mon + , t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
      printf("yday: %d \t wday: %d \t isdst: %d\n\n",
                     t->tm_yday, t->tm_wday, t->tm_isdst);
 }

 int main(int argc, char* argv[])
 {
      // time
      time_t t = time(NULL);
      printf("time: %d\n\n", static_cast<int>(t));

      // ctime and ctime_r
      char* c1 = ctime(&t);
      printf("ctime: c1: %s\n", c1);

      char c20[];
      char* c2 = ctime_r(&t, c20);
      printf("ctime_r: c2: %s \t c20: %s \n\n", c2, c20);

      // gmtime and gmtime_r
      tm* t1 = gmtime(&t);
      ShowTM("gmtime-t1", t1);

      tm t20;
      tm* t2 = gmtime_r(&t, &t20);
      ShowTM("gmtime_r-t2", t2);
      ShowTM("gmtime_r-t20", &t20);

      // localtime and localtime_r
      tm* t3 = localtime(&t);
      ShowTM("localtime-t3", t3);

      tm t40;
      tm* t4 = localtime_r(&t, &t40);
      ShowTM("localtime_r-t4", t4);
      ShowTM("localtime_r-t40", &t40);

      // asctime and asctime_r
      char* asc1 = asctime(t1);
      printf("asctime-gmtime: %s\n", asc1);

      char asc20[];
      char* asc2 = asctime_r(t1, asc20);
      printf("asctime-gmtime: asc2: %s \t asc20: %s\n", asc2, asc20);

      char* asc3 = asctime(t3);
      printf("asctime-localtime: %s\n", asc3);

      char asc40[];
      char* asc4 = asctime_r(t3, asc40);
      printf("asctime-localtime: asc4: %s \t asc40: %s\n", asc4, asc40);

      // mktime
      time_t mkt1 = mktime(t1);
      printf("mktime-gmtime: %d\n\n", static_cast<int>(mkt1));

      time_t mkt2 = mktime(t3);
      printf("mktime-localtime: %d\n", static_cast<int>(mkt2));

      return ;
 }

运行结果：

time: 1513421843

ctime: c1: Sat Dec 16 18:57:23 2017

ctime_r: c2: Sat Dec 16 18:57:23 2017
         c20: Sat Dec 16 18:57:23 2017

gmtime-t1:
2017-12-16 10:57:23
yday: 349        wday: 6         isdst: 0

gmtime_r-t2:
2017-12-16 10:57:23
yday: 349        wday: 6         isdst: 0

gmtime_r-t20:
2017-12-16 10:57:23
yday: 349        wday: 6         isdst: 0

localtime-t3:
2017-12-16 18:57:23
yday: 349        wday: 6         isdst: 0

localtime_r-t4:
2017-12-16 18:57:23
yday: 349        wday: 6         isdst: 0

localtime_r-t40:
2017-12-16 18:57:23
yday: 349        wday: 6         isdst: 0

asctime-gmtime: Sat Dec 16 18:57:23 2017

asctime-gmtime: asc2: Sat Dec 16 18:57:23 2017
         asc20: Sat Dec 16 18:57:23 2017

asctime-localtime: Sat Dec 16 18:57:23 2017

asctime-localtime: asc4: Sat Dec 16 18:57:23 2017
         asc40: Sat Dec 16 18:57:23 2017

mktime-gmtime: 1513421843

mktime-localtime: 1513421843

本文参考自：

《APUE》第3版

http://elixir.free-electrons.com/linux/latest/source/include/uapi/linux/time.h

https://linux.die.net/man/2/clock_gettime

http://blog.****.net/droidphone/article/details/7989566

http://blog.chinaunix.net/uid-20662820-id-3880162.html

http://wuzhiwei.net/one_overflow_issue/

http://www.cnblogs.com/Solstice/archive/2011/02/06/1949555.html