第一章获取时间函数
第二章计算时间差
include
clock_t times(struct tms *buf); 单位 10 毫秒 (ms) times 实际上面就是调用 clock() 实现的。
- clock

参考： http://www.cnblogs.com/krythur/archive/2013/02/25/2932647.html

第一章获取时间函数

asctime

函数定义
char * asctime(const [struct](https://so.csdn.net/so/search?q=struct&spm=1001.2101.3001.7020) tm * timeptr);

函数说明
asctime() 将参数 timeptr 所指的 tm 结构中的信息转换成真实世界所使用的时间日期表示方法，然后将结果以字符串形态返回。此函数已经由时区转换成当地时间，字符串格式为:“Wed Jun 30 21:49:08 1993\n”

返回值
若再调用相关的时间日期函数，此字符串可能会被破坏。此函数与 ctime 不同处在于传入的参数是不同的结构。

附加说明
返回一字符串表示目前当地的时间日期。

示例

#include <stdio.h>
#include <time.h>
int main(void)
{
    time_t timep;
    time(&timep);
    printf("%s", asctime(gmtime(&timep)));
    return 0;
}

运行结果
Tue Aug 2 11:44:14 2022

ctime

定义函数
char *ctime(const time_t *timep);

函数说明
ctime() 将参数 timep 所指的 time_t 结构中的信息转换成真实世界所使用的时间日期表示方法，然后将结果以字符串形态返回。此函数已经由时区转换成当地时间，字符串格式为 “Wed Jun 30 21 :49 :08 1993\n”。若再调用相关的时间日期函数，此字符串可能会被破坏。

返回值
返回一字符串表示目前当地的时间日期。

示例

#include <stdio.h>
#include <time.h>
int main(void)
{
    time_t timep;
    time(&timep);
    printf("%s", ctime(&timep));
    return 0;
}

运行结果
Tue Aug 2 19:46:27 2022

gmtime

函数定义
struct tm* gmtime(const time_t*timep);

函数说明
gmtime() 将参数 timep 所指的 time_t 结构中的信息转换成真实世界所使用的时间日期表示方法，然后将结果由结构 tm 返回。

结构 tm 的定义为：

struct tm {
    int tm_sec;
    int tm_min;
    int tm_hour;
    int tm_mday;
    int tm_mon;
    int tm_year;
    int tm_wday;
    int tm_yday;
    int tm_isdst;
};

int tm_sec 代表目前秒数，正常范围为 0-59，但允许至 61 秒
int tm_min 代表目前分数，范围 0-59
int tm_hour 从午夜算起的时数，范围为 0-23
int tm_mday 目前月份的日数，范围 01-31
int tm_mon 代表目前月份，从一月算起，范围从 0-11
int tm_year 从 1900 年算起至今的年数
int tm_wday 一星期的日数，从星期一算起，范围为 0-6
int tm_yday 从今年 1 月 1 日算起至今的天数，范围为 0-365
int tm_isdst 日光节约时间的旗标
此函数返回的时间日期未经时区转换，而是 UTC 时间。

返回值
返回结构 tm 代表目前 UTC 时间

示例

#include <stdio.h>
#include <time.h>
int main(void)
{
    char *wday[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
    time_t timep;
    struct tm *p;
    time(&timep);
    p = gmtime(&timep);
    printf("%d %d %d\n", (1900 + p->tm_year), (1 + p->tm_mon), p->tm_mday);
    printf("%s %d:%d:%d\n", wday[p->tm_wday], p->tm_hour, p->tm_min, p->tm_sec);
    return 0;
}

运行结果
2022 8 2
Tue 11:50:21

localtime

函数定义
struct tm *localtime(const time_t * timep);

函数说明
localtime() 将参数 timep 所指的 time_t 结构中的信息转换成真实世界所使用的时间日期表示方法，然后将结果由结构 tm 返回。结构 tm 的定义请参考 gmtime()。此函数返回的时间日期已经转换成当地时区。

返回值
返回结构 tm 代表目前的当地时间。

示例

#include <stdio.h>
#include <time.h>
int main(void)
{
    char *wday[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
    time_t timep;
    struct tm *p;
    time(&timep);
    p = localtime(&timep); /*取得当地时间*/
    printf("%d %d %d\n", (1900 + p->tm_year), 1 + p->tm_mon, p->tm_mday);
    printf("%s %d: %d: %d\n", wday[p->tm_wday], p->tm_hour, p->tm_min, p->tm_sec);
    return 0;
}

运行结果
2022 8 2
Tue 19: 54: 50

mktime

函数定义
time_t mktime(strcut tm * timeptr);

函数说明
mktime() 用来将参数 timeptr 所指的 tm 结构数据转换成从公元 1970 年 1 月 1 日 0 时 0 分 0 秒算起至今的 UTC 时间所经过的秒数。

返回值
返回经过的秒数。

示例

 /* 用 time() 取得时间（秒数），利用 localtime()
转换成 struct tm 再利用 mktine（）将 struct tm 转换成原来的秒数*/
#include <stdio.h>
#include <time.h>
int main(void)
{
    time_t timep;
    struct tm *p;
    time(&timep);
    printf("time() : %ld \n", timep);
    p = localtime(&timep);
    timep = mktime(p);
    printf("time()->localtime()->mktime() : %ld\n", timep);
    return 0;
}

运行结果
time() : 1659441407
time()->localtime()->mktime() : 1659441407``

time

函数定义
time_t time(time_t *t);

函数说明
此函数会返回从公元 1970 年 1 月 1 日的 UTC 时间从 0 时 0 分 0 秒算起到现在所经过的秒数。如果 t 并非空指针的话，此函数也会将返回值存到 t 指针所指的内存。

返回值
成功则返回秒数，失败则返回 ((time_t)-1) 值，错误原因存于 errno 中。

示例

#include <stdio.h>
#include <time.h>
int main(void)
{
    long seconds = time((time_t *)NULL);
    printf("%ld\n", seconds);
    return 0;
}

gettimeofday

函数定义
int gettimeofday (struct timeval * tv, struct timezone * tz)

函数说明
函数gettimeofday()可获得微妙级（0.000001 秒）的系统时间，调用两次 gettimeofday()，前后做减法，从而达到定时或者计算时间的目的。

参数说明

struct timeval{ 
　　long tv_sec; //秒 
　　long tv_usec; //微秒 
};
struct timezone 
{ 
　　int tz_minuteswest; //和Greenwich 时间差了多少分钟 
　　int tz_dsttime; //日光节约时间的状态 
};

返回值
该函数成功时返回0，失败时返回-1

char asctime(const struct tm tm);
char asctime_r(const struct tm tm, char buf);
char ctime(const time_t timep);
char ctime_r(const time_t timep, char buf);
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);
double difftime(time_t time1, time_t time0);
int gettimeofday(struct timeval tv, struct timezone tz);
int settimeofday(const struct timeval tv , const struct timezone *tz);

示例

#include <stdio.h>
#include <sys/time.h>
#include <unistd.h>
int main()
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    printf("second: %ld\n", tv.tv_sec); // 秒
    printf("millisecond: %ld\n", tv.tv_sec * 1000 + tv.tv_usec / 1000); // 毫秒
    printf("microsecond: %ld\n", tv.tv_sec * 1000000 + tv.tv_usec); // 徽秒
    sleep(3); // 让程序休眠3秒
    printf("---------------------sleep 3 second-------------------\n");
    gettimeofday(&tv, NULL);
    printf("second: %ld\n", tv.tv_sec); // 秒
    printf("millisecond: %ld\n",
           tv.tv_sec * 1000 + tv.tv_usec / 1000); // 毫秒
    printf("microsecond: %ld\n", tv.tv_sec * 1000000 + tv.tv_usec); // 徽秒
    return 0;
}

运行结果：

second: 1659441664
millisecond: 1659441664553
microsecond: 1659441664553395
---------------------sleep 3 second-------------------
second: 1659441667
millisecond: 1659441667553
microsecond: 1659441667553520

第二章计算时间差

clock_gettime

函数定义
在 POSIX1003.1 中增添了这个函数, 它的原型如下：
int clock_gettime(clockid_t clk_id, struct timespec *tp);

函数说明
实时函数 clock_gettime 单位是十亿分之一秒，也就是纳秒 (ns)，使用的是标准 POSIX 实时时钟，计算出来的结果可能有误差。

参数说明
struct timespec ,timespec 计算时间次数的单位是十亿分之一秒.

struct timespec{
 time_t tv_sec;/* Seconds.  */
 long tv_nsec;/* Nanoseconds.  */
}

clockid_t 是确定哪个时钟类型：
CLOCK_REALTIME: 标准 POSIX 实时时钟
CLOCK_MONOTONIC: POSIX 时钟, 以恒定速率运行; 不会复位和调整, 它的取值和 CLOCK_REALTIME 是一样的.
CLOCK_PROCESS_CPUTIME_ID 和 CLOCK_THREAD_CPUTIME_ID 是 CPU 中的硬件计时器中实现的.

示例

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#define BILLION 1000 * 1000 * 1000L
int main(void)
{
    long int loop = 1000;
    struct timespec ts_start;
    struct timespec ts_end;
    long time_span;
    clock_gettime(CLOCK_MONOTONIC, &ts_start);
    sleep(1);
    clock_gettime(CLOCK_MONOTONIC, &ts_end);
    time_span = BILLION * (ts_end.tv_sec - ts_start.tv_sec) +
            ts_end.tv_nsec - ts_start.tv_nsec;
    fprintf(stdout, "it took %ld nanoseconds\n", time_span);
    return 0;
}

编译:
gcc test3.c -lrt -o test3

计算时间:
time ./test3
it took 1000060679 nanoseconds

gettimeofday

int gettimeofday(struct timeval tv,struct timezonetz), 会把目前的时间 tv 所指的结构返回，当地时区的信息则放到 tz 所指的结构中。这两个结构都放在 / usr/include/sys/time.h 中。单位微秒 (μs)

示例

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#define MILLION 1000 * 1000L
int main(void)
{
    long time_span = 0;
    struct timeval start;
    struct timeval end;
    //struct timezone tz; // 后面有说明
    // 注意：gettimeofday需要头文件#include <sys/time.h>
    gettimeofday(&start, NULL); //gettimeofday(&start,&tz); 结果一样
    printf("start.tv_sec:%ld\n", start.tv_sec);
    printf("start.tv_usec:%ld\n", start.tv_usec);
    sleep(3);
    gettimeofday(&end, NULL);
    printf("end.tv_sec:%ld\n", end.tv_sec);
    printf("end.tv_usec:%ld\n", end.tv_usec);
    time_span = (end.tv_sec - start.tv_sec) * MILLION +
            (end.tv_usec - start.tv_usec); // 微秒
    printf("time span is %ld microseconds\n", time_span);
    return 0;
}

输出
start.tv_sec:1659491954
start.tv_usec:582517
end.tv_sec:1659491957
end.tv_usec:582629
time span is 3000112 microseconds

下面的采用指针的方式也可以，但是要注意指针类型若不分配内存的话，编译正确，但是运行结果会不对

times

include
clock_t times(struct tms *buf); 单位 10 毫秒 (ms) times 实际上面就是调用 clock() 实现的。

times() 函数返回从过去一个任意的时间点所经过的时钟数。返回值可能会超出 clock_t (一般为 long 型) 的范围 (溢出)。如果发生错误，则返回 (clock_t ) -1 类型，然后设置相应的 errno 值。

系统每秒的时钟可以通过 sysconf(_SC_CLK_TCK); 函数获得。

tms 结构体如下:
strace tms{
clock_t tms_utime;
clock_t tms_stime;
clock_t tms_cutime;
clock_t tms_cstime;
}

注释:
tms_utime 记录的是进程运行结果用户代码的时间.
tms_stime 记录的是进程运行结果内核代码的时间.
tms_cutime 记录的是子进程运行结果用户代码的时间.
tms_cstime 记录的是子进程运行结果内核代码的时间.

测试:

vi test2.c

#include <sys/times.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
static void do_cmd(char *);
static void pr_times(clock_t, struct tms *, struct tms *);
int main(int argc, char *argv[])
{
    int i;
    for (i = 1; argv[i] != NULL; i++) {
        do_cmd(argv[i]);
    }
    exit(1);
}
static void do_cmd(char *cmd)
{
    struct tms tmsstart, tmsend;
    clock_t start, end;
    int status;
    if ((start = times(&tmsstart)) == -1)
        puts("times error");
    if ((status = system(cmd)) < 0)
        puts("system error");
    if ((end = times(&tmsend)) == -1)
        puts("times error");
    pr_times(end - start, &tmsstart, &tmsend);
    exit(0);
}
static void pr_times(clock_t real, struct tms *tmsstart, struct tms *tmsend)
{
    static long clktck = 0;
    if (0 == clktck)
        if ((clktck = sysconf(_SC_CLK_TCK)) < 0)
            puts("sysconf err");
    printf("real:%7.2f\n", real / (double)clktck);
    printf("user-cpu:%7.2f\n",
           (tmsend->tms_utime - tmsstart->tms_utime) / (double)clktck);
    printf("system-cpu:%7.2f\n",
           (tmsend->tms_stime - tmsstart->tms_stime) / (double)clktck);
    printf("child-user-cpu:%7.2f\n",
           (tmsend->tms_cutime - tmsstart->tms_cutime) / (double)clktck);
    printf("child-system-cpu:%7.2f\n",
           (tmsend->tms_cstime - tmsstart->tms_cstime) / (double)clktck);
}

编译:
gcc test2.c -o test2

测试这个程序:
time ./test2 “dd if=/dev/zero f=/dev/null bs=1M count=10000”
10000+0 records in
10000+0 records out
10485760000 bytes (10 GB) copied, 4.93028 s, 2.1 GB/s
real: 4.94
user-cpu: 0.00
system-cpu: 0.00
child-user-cpu: 0.01
child-system-cpu: 4.82

clock

#include
clock_t clock(void); 单位 10 毫秒 (ms)
int clock_gettime(clockid_t clk_id, struct timespec *tp);
系统每秒的时钟可以通过 sysconf(_SC_CLK_TCK); 函数获得。

以下是各种精确度的类型转换:
1 秒 = 1000 毫秒 (ms), 1 毫秒 = 1/1000 秒 (s)；
1 秒 = 1000000 微秒 (μs), 1 微秒 = 1/1000000 秒 (s)；
1 秒 = 1000000000 纳秒 (ns),1 纳秒 = 1/1000000000 秒 (s)；

clock() 函数的精确度是 10 毫秒 (ms)
times() 函数的精确度是 10 毫秒 (ms)
gettimofday() 函数的精确度是微秒 (μs)
clock_gettime() 函数的计量单位为十亿分之一，也就是纳秒 (ns)

3） times() 和 clock()

默认的 Linux 时钟周期是 100HZ, 而现在最新的内核时钟周期默认为 250HZ.
如何得到内核的时钟周期呢?
grep ^CONFIG_HZ /boot/config-2.6.26-1-xen-amd64

CONFIG_HZ_250=y
CONFIG_HZ=250

结果就是 250HZ.

而用 sysconf(_SC_CLK_TCK); 得到的却是 100HZ
例如:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
// #include <time.h>
// #include <sys/time.h>
int main(int argc, char *argv[])
{
    long tps = sysconf(_SC_CLK_TCK);
    printf("%ld\n", tps);
    return EXIT_SUCCESS;
}

为什么得到的是不同的值呢？
因为 sysconf(_SC_CLK_TCK) 和 CONFIG_HZ 所代表的意义是不同的.
sysconf(_SC_CLK_TCK) 是 GNU 标准库的 clock_t 频率.
它的定义位置在:/usr/include/asm/param.h

例如:
#ifndef HZ
#define HZ 100
#endif

最后总结一下内核时间:
内核的标准时间是 jiffy, 一个 jiffy 就是一个内部时钟周期, 而内部时钟周期是由 250HZ 的频率所产生中的, 也就是一个时钟滴答, 间隔时间是 4 毫秒 (ms).

也就是说:
1 个 jiffy=1 个内部时钟周期 = 250HZ=1 个时钟滴答 = 4 毫秒

sysconf(_SC_CLK_TCK) 使用默认的 Linux 时钟周期是 100HZ， 1 个 jiffy=1 个内部时钟周期 = 100HZ=1 个时钟滴答 = 10 毫秒，所以 clock（）和 times（）的最新单位是 10ms

每经过一个时钟滴答就会调用一次时钟中断处理程序，处理程序用 jiffy 来累计时钟滴答数, 每发生一次时钟中断就增 1.
而每个中断之后, 系统通过调度程序跟据时间片选择是否要进程继续运行, 或让进程进入就绪状态.

https://blog.csdn.net/sunny04/article/details/41848295

软件开发

linux获取时间函数及计算时间差

第一章获取时间函数

asctime

ctime

gmtime

localtime

mktime

time

gettimeofday

第二章计算时间差

clock_gettime

gettimeofday

times

include
clock_t times(struct tms *buf); 单位 10 毫秒 (ms) times 实际上面就是调用 clock() 实现的。

clock

linux获取时间函数及计算时间差

第一章 获取时间函数

asctime

ctime

gmtime

localtime

mktime

time

gettimeofday

第二章 计算时间差

clock_gettime

gettimeofday

times

include clock_t times(struct tms *buf); 单位 10 毫秒 (ms) times 实际上面就是调用 clock() 实现的。

clock

第一章获取时间函数

第二章计算时间差

include
clock_t times(struct tms *buf); 单位 10 毫秒 (ms) times 实际上面就是调用 clock() 实现的。