目录
1、获取系统信息
1.1、uname()函数
1.2、sysinfo ()函数
1.3、gethostname ()函数
1.4、sysconf()函数
1.5、getpagesize()函数
2、时间/日期
2.1、查看utc时间
2.2、查看系统本地时间
2.3、时区信息配置文件
2.4、系统本地时间配置文件
2.5、修改系统本地时间
2.6、jiffies变量
2.7、时间相关函数
2.8、设置时间
2.8.1、stime()函数
2.8.2、 settimeofday()函数
2.9、获取时间
2.9.1、time()函数
2.9.2、gettimeofday()函数
2.9.3、获取时间差
2.10、时间转换为字符串
2.10.1、ctime ()函数
2.10.2、ctime_r()函数
2.10.3、asctime ()函数
2.10.4、asctime_r()函数
2.10.5、strftime ()函数
2.11、字符串转换为时间
2.11.1、strptime()函数
2.12、时间格式转换
2.12.1、localtime ()函数
2.12.2 、localtime_r()函数
2.12.3、gmtime ()函数
2.12.4、gmtime_r()函数
2.12.5、mktime()函数
3、进程时间
3.1、time命令
3.1.1、统计时间
3.2、time输出指标
3.2.1、时间
3.2.2、内存
3.2.3、I/O
3.3、times() 函数
3.4、clock() 函数
3.5、clock_gettime()函数
4、随机数
4.1、rand ()函数
4.2、srand ()函数
4.3、random()函数
4.4、srandom()函数
4.5、initstate()函数
4.6、setstate()函数
5、休眠
5.1、sleep()函数
5.2、usleep()函数
5.3、nanosleep()函数
6、内存分配
6.1、malloc()函数
6.2、free()函数
6.3、calloc()函数
6.4、posix_memalign()函数
6.5、aligned_alloc()函数
6.6、memalign()函数
6.7、valloc()函数
6.8、pvalloc()函数
7、定时器
7.1、setitimer()函数
7.2、getitimer()函数
用于获取有关当前操作系统内核的名称和信息。
#include <sys/utsname.h>
int uname(struct utsname *buf);参数 buf： struct utsname 结构体类型指针， 指向一个 struct utsname 结构体类型对象。
返回值： 成功返回 0；失败将返回-1，并设置 errno。
struct utsname {
char sysname[]; /* 当前操作系统的名称 */
char nodename[]; /* 网络上的名称（主机名） */
char release[]; /* 操作系统内核版本 */
char version[]; /* 操作系统发行版本 */
char machine[]; /* 硬件架构类型 */
#ifdef _GNU_SOURCE
char domainname[]; /* 当前域名 */
#endif
};可用于获取一些系统统计信息。
#include <sys/sysinfo.h>
int sysinfo(struct sysinfo *info);参数 info： struct sysinfo 结构体类型指针，指向一个 struct sysinfo 结构体类型对象。
返回值： 成功返回 0；失败将返回-1，并设置 errno。
struct sysinfo {
long uptime; /* 自系统启动之后所经过的时间（以秒为单位） */
unsigned long loads[3]; /* 1, 5, and 15 minute load averages */
unsigned long totalram; /* 总的可用内存大小 */
unsigned long freeram; /* 还未被使用的内存大小 */
unsigned long sharedram; /* Amount of shared memory */
unsigned long bufferram; /* Memory used by buffers */
unsigned long totalswap; /* Total swap space size */
unsigned long freeswap; /* swap space still available */
unsigned short procs; /* 系统当前进程数量 */
unsigned long totalhigh; /* Total high memory size */
unsigned long freehigh; /* Available high memory size */
unsigned int mem_unit; /* 内存单元大小（以字节为单位） */
char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding to 64 bytes */
};此函数可用于单独获取 Linux 系统主机名， 与 struct utsname 数据结构体中的 nodename 变量一样。
#include <unistd.h>
int gethostname(char *name, size_t len);参数 name： 指向用于存放主机名字符串的缓冲区。
参数 len： 缓冲区长度。
返回值： 成功返回 0,；失败将返回-1，并会设置 errno。
sysconf()函数是一个库函数，可在运行时获取系统的一些配置信息，譬如页大小（page size）、主机名的最大长度、进程可以打开的最大文件数、 每个用户 ID 的最大并发进程数等。
#include <unistd.h>
long sysconf(int name);参数 name:
| _SC_ARG_MAX | exec 族函数的参数的最大长度 |
| _SC_CHILD_MAX | 每个用户的最大并发进程数，也就是同一个用户可以同时运行的最大进程数 |
| _SC_HOST_NAME_MAX | 主机名的最大长度。 |
| _SC_LOGIN_NAME_MAX | 登录名的最大长度。 |
| _SC_CLK_TCK | 每秒时钟滴答数，也就是系统节拍率。 |
| _SC_OPEN_MAX | 一个进程可以打开的最大文件数 |
| _SC_MQ_OPEN_MAX | 一个进程能够同时拥有打开着的消息队列的最大数目 |
| _SC_PAGESIZE | 系统页大小 |
| _SC_TTY_NAME_MAX | 终端设备名称的最大长度 |
| ... | ... |
返回值：若指定的参数 name 为无效值，则 sysconf()函数返回-1，并会将 errno 设置为 EINVAL。否则返回的值便是对应的配置值。
获取页大小，等价于sysconf(_SC_PAGESIZE)。
#include <unistd.h>
int getpagesize(void);返回值：返回页大小的值。
date -u
date
/usr/share/zoneinfo
/etc/localtime
系统的本地时间由时区配置文件/etc/localtime 定义，通常链接到/usr/share/zoneinfo 目录下的某一个文件（或其子目录下的某一个文件）。修改系统本地时间的时区信息，可以直将/etc/localtime 链接到/usr/share/zoneinfo目录下的任意一个时区配置文件。
例如：
rm /etc/localtime
ln -s /usr/share/zoneinfo/Asia/Shanghai /etc/localtimejiffies 是内核中定义的一个全局变量，内核使用 jiffies 来记录系统从启动以来的系统节拍数， 所以这个变量用来记录以系统节拍时间为单位的时间长度。时间由jiffies换算得到。
| 设置时间 | |
| stime() | 使用time_t设置系统时间 |
| settimeofday() | 使用struct timeval设置系统时间 |
| 获取时间 | |
| time() | 获取time_t类型的UTC时间 |
| gettimeofday() | 获取struct timeval类型的UTC时间 |
| difftime() | 获取两个time_t型变量之间的时间差。 |
| 将时间转换为字符串 | |
| ctime() | 将time_t转换为可打印输出的字符串形式(固定格式) |
| asctime() | 将struct tm转换为可打印输出的字符串形式(固定格式) |
| strftime() | 将struct tm转换为可打印输出的字符串形式(自定义格式) |
| 将字符串转换为时间 | |
| strptime() | 将字符串转换为struct tm形式 |
| 时间格式转化 | |
| localtime() | 把 time_t 时间转换为struct tm结构体(本地时间) |
| gmtime() | 把 time_t 时间转换为struct tm结构体(UTC时间) |
| mktime() | 将使用 struct tm 结构体表示的分解时间转换为time_t |
设置系统时间时内核会进行权限检查，只有超级用户（root）才可以设置系统时间，普通用户将无操作权限。
设置系统时间。
#include <time.h>
int stime(const time_t *t);参数 t： 参数 t 是一个 time_t 指针变量。
返回值： 成功返回 0；失败将返回-1，并设置 errno。
设置系统时间。
#include <sys/time.h>
int settimeofday(const struct timeval *tv, const struct timezone *tz);参数 tv： 参数 tv 是一个 struct timeval 结构体指针变量。
参数 tz： 参数 tz 是个历史产物，早期实现用其来设置系统的时区信息，目前已遭废弃，在调用 settimeofday()函数时应将参数 tz 设置为 NULL。
返回值： 成功返回 0；失败将返回-1，并设置 errno。
系统调用 time()用于获取当前时间，以秒为单位，返回得到的值是自 1970-01-01 00:00:00 +0000 (UTC)以来的秒数。
#include <time.h>
time_t time(time_t *tloc);参数 tloc： 如果 tloc 参数不是 NULL，则返回值也存储在 tloc 指向的内存中。
返回值： 成功则返回自 1970-01-01 00:00:00 +0000 (UTC)以来的时间值（以秒为单位） ；失败则返回-1，并会设置 errno。
gettimeofday()函数提供微秒级时间精度。
#include <sys/time.h>
int gettimeofday(struct timeval *tv, struct timezone *tz);参数 tv： 参数 tv 是一个 struct timeval 结构体指针变量。
struct timeval {
time_t tv_sec; /* seconds */
suseconds_t tv_usec; /* microseconds */
}; 参数 tz： 参数 tz 是个历史产物，早期实现用其来获取系统的时区信息，目前已遭废弃，在调用 gettimeofday()函数时应将参数 tz 设置为 NULL。
返回值： 成功返回 0；失败将返回-1，并设置 errno。
返回两个time_t型变量之间的时间间隔，即 计算两个时刻之间的时间差。
#include <time.h>
double difftime(time_t time2, time_t time1);参数 time2：被减数
参数 time1：减数
返回值：时间差(单位秒)。
可以将时间转换为可打印输出的字符串形式。
#include <time.h>
char *ctime(const time_t *timep);参数 timep： time_t 时间变量指针。
返回值： 成功将返回一个 char *类型指针，指向转换后得到的字符串；失败将返回 NULL。
ctime()是一个不可重入函数， 存在一些安全上面的隐患， ctime_r()是 ctime()的可重入版本。
#include <time.h>
char *ctime_r(const time_t *timep, char *buf);参数 timep： time_t 时间变量指针。
参数 buf:存放字符串的缓冲区
返回值： 成功将返回一个 char *类型指针，指向转换后得到的字符串；失败将返回 NULL。
asctime()函数与 ctime()函数的作用一样，也可将时间转换为可打印输出的字符串形式，与 ctime()函数的区别在于， ctime()是将 time_t 时间转换为固定格式字符串、而 asctime()则是将 struct tm 表示的分解时间转换为固定格式的字符串。
#include <time.h>
char *asctime(const struct tm *tm);asctime ()函数的可重入版本。
#include <time.h>
char *asctime_r(const struct tm *tm, char *buf);此函数也可以将一个 struct tm 变量表示的分解时间转换为为格式化字符串，并且在功能上比 asctime()和 ctime()更加强大，可以根据自定义时间的显示格式，而 asctime()和 ctime()转换得到的字符串时间格式的固定的。
#include <time.h>
size_t strftime(char *s, size_t max, const char *format, const struct tm *tm);参数 s： 指向一个缓存区的指针，该缓冲区用于存放生成的字符串。
参数 max： 字符串的最大字节数。
参数 format： 这是一个用字符串表示的字段， 包含了普通字符和特殊格式说明符，可以是这两种字符的任意组合。 特殊格式说明符将会被替换为 struct tm 结构体对象所指时间的相应值。
| 说明符 | 表示含义 |
| %a | 星期的缩写 |
| %A | 星期的完整名称 |
| %b | 月份的缩写 |
| %B | 月份的完整名称 |
| %c | 系统当前语言环境对应的首选日期和时间表示形式 |
| %C | 世纪（年/100） |
| %d | 十进制数表示一个月中的第几天（01-31） |
| %D | 相当于％m/％d/％y |
| %e | 与%d 相同，但是单个数字时，前导 0 会被去掉 |
| %F | 相当于%Y-%m-%d |
| %h | 相当于%b |
| %H | 十进制数表示的 24 小时制的小时（范围 00-23） |
| %I | 十进制数表示的 12 小时制的小时（范围 01-12） |
| %j | 十进制数表示的一年中的某天（范围 001-366） |
| %k | 与%H 相同，但是单个数字时，前导 0 会被去掉（范围 0-23） |
| %l | 与%I 相同，但是单个数字时，前导 0 会被去掉（范围 1-12） |
| %m | 十进制数表示的月份（范围 01-12） |
| %M | 十进制数表示的分钟（范围 00-59） |
| %n | 换行符 |
| %p | 根据给定的时间值，添加“AM”或“PM” |
| %P | 与%p 相同，但会使用小写字母表示 |
| %r | 相当于%I:%M:%S %p |
| %R | 相当于%H:%M |
| %S | 十进制数表示的秒数（范围 00-60） |
| %T | 相当于%H:%M:%S |
| %u | 十进制数表示的星期（范围 1-7，星期一为 1） |
| %U | 十进制数表示，当前年份的第几个星期（范围 00-53），从第 一个星期日作为 01 周的第一天开始 |
| %W | 十进制数表示，当前年份的第几个星期（范围 00-53）， 从第 一个星期一作为第 01 周的第一天开始 |
| %w | 十进制数表示的星期，范围为 0-6，星期日为 0 |
| %x | 系统当前语言环境的首选日期表示形式，没有时间 |
| %X | 系统当前语言环境的首选时间表示形式，没有日期 |
| %y | 十进制数表示的年份（后两字数字） |
| %Y | 十进制数表示的年份（4 个数字） |
| %% | 输出%符号 |
参数 tm： 指向 struct tm 结构体对象的指针。
返回值： 如果转换得到的目标字符串不超过最大字节数（也就是 max），则返回放置到 s 数组中的字节数；如果超过了最大字节数，则返回 0。
按照特定时间格式将字符串转换为时间类型。
#include <time.h>
char *strptime(const char *s, const char *format, struct tm *tm);参数 s： 指向 struct tm 结构体对象的指针。
参数 format：转换格式。
参数 tm： 指向 struct tm 结构体对象的指针。
返回值：函数的返回值是指向该函数调用中未处理的第一个字符的指针。如果输入字符串包含的字符多于格式字符串所需的字符，则返回值正好位于最后一个使用的输入字符之后。如果使用了整个输入字符串，则返回值指向字符串末尾的空字节。如果strptime()未能匹配所有格式字符串，因此出现错误，则函数返回NULL。
将time_t时间转换为tm结构体的形式。
#include <time.h>
struct tm *localtime(const time_t *timep);
参数 timep： 需要进行转换的 time_t 时间变量对应的指针。
返回值： 返回一个struct tm 结构体指针。
struct tm {
int tm_sec; /* 秒(0-60) */
int tm_min; /* 分(0-59) */
int tm_hour; /* 时(0-23) */
int tm_mday; /* 日(1-31) */
int tm_mon; /* 月(0-11) */
int tm_year; /* 年(这个值表示的是自 1900 年到现在经过的年数) */
int tm_wday; /* 星期(0-6, 星期日 Sunday = 0、星期一=1…) */
int tm_yday; /* 一年里的第几天(0-365, 1 Jan = 0) */
int tm_isdst; /* 夏令时 */
};localtime函数的可重入版本。
#include <time.h>
struct tm *localtime_r(const time_t *timep, struct tm *result);参数 timep： 需要进行转换的 time_t 时间变量对应的指针。
参数 result：
返回值： 成功返回一个struct tm 结构体指针，失败则返回 NULL。
gmtime()函数也可以把 time_t 时间变成一个 struct tm 结构体所表示的时间，与 localtime()所不同的是，gmtime()函数所得到的是 UTC 国际标准时间，并不是计算机的本地时间。
#include <time.h>
struct tm *gmtime(const time_t *timep);
gmtime_r()函数是gmtime()函数的可重入版本
#include <time.h>
struct tm *gmtime_r(const time_t *timep, struct tm *result);mktime()函数与 localtime()函数相反， mktime()可以将使用 struct tm 结构体表示的分解时间转换为 time_t时间。
#include <time.h>
time_t mktime(struct tm *tm);参数 tm： 需要进行转换的 struct tm 结构体变量对应的指针。
返回值： 成功返回转换得到 time_t 时间值；失败返回-1。
进程时间指的是进程从创建后（也就是程序运行后）到目前为止这段时间内使用 CPU 资源的时间总数，内核把 CPU 时间（进程时间） 分为以下两个部分：
1、用户 CPU 时间：进程在用户空间（用户态）下运行所花费的 CPU 时间。
2、系统 CPU 时间：进程在内核空间（内核态）下运行所花费的 CPU 时间。这是内核执行系统调用或代表进程执行的其它任务（譬如，服务页错误）所花费的时间。
注：一般来说，进程时间指的是用户 CPU 时间和系统 CPU 时间的总和，也就是总的 CPU 时间。进程时间不等于程序的整个生命周期所消耗的时间， 如果进程一直处于休眠状态（进程被挂起、
不会得到系统调度），那么它并不会使用 CPU 资源，所以休眠的这段时间并不计算在进程时间中。
可以使用time命令查看程序的运行时间、用户cpu时间系统cpu时间。
注：time命令指代的是Shell 内置的 time 命令。 \time命令，它指代是/usr/bin/time，/usr/bin/time 命令可以显示更多的信息，而 Shell 内置的命令做不到这一点。
| real | 从进程开始执行到完成所耗费的 CPU 总时间。 | 该时间包括进程执行时实际使用的 CPU 时间，进程耗费在阻塞上的时间（如等待完成 I/O 操作）和其他进程所耗费的时间（Linux 是多进程系统，进程在执行过程中，可能会有别的进程抢占 CPU）。 |
| user | 进程执行用户态代码所耗费的 CPU 时间。 | 该时间仅指进程执行时实际使用的CPU 时间，而不包括其他进程所使用的时间和本进程阻塞的时间。 |
| sys | 进程在内核态运行所耗费的 CPU 时间 | 即执行内核系统调用所耗费的 CPU 时间。 |
注：一般情况下real_time>=user_time+sys_time。但也有可能real_time<user_time+sys_time(多核 CPU时可能出现)。
| 指 标 | 含 义 |
|---|---|
| Elapsed (wall clock) time | 执行命令所花费的时间，格式是：[hour]:minute:second |
| System time | 命令执行时在内核模式所花费的时间，单位是秒 |
| User time | 命令执行时在使用者模式所花费的时间，单位是秒 |
| Percent of CPU this job got | 命令执行时 CPU 的占用比例。 其实这个数字就是内核模式的 CPU 时间加上使用者模式的 CPU 时间除以总时间 |
| 指 标 | 含 义 |
|---|---|
| Maximum resident set size | 执行程序所占用内存的最大值。单位是 KB |
| Average resident set size | 执行程序所占用内存的平均值，单位是 KB |
| Average total size | 执行程序所占用的内存总量（stack+data+text）的平均大小， 单位是 KB |
| Average unshared data size | 执行程序所占用的私有数据区（unshared data area）的平均 大小，单位是 KB |
| Average stack size | 执行程序所占用的私有堆栈（unshared stack）的平均大小， 单位是 KB |
| Average shared text size | 执行程序间共享内容（shared text）的平均值，单位是 KB |
| Page size | 系统内存页的大小，单位是 byte。对于同一个系统来说，这 是个常数 |
| 指 标 | 含 义 |
|---|---|
| Major (requiring I/O) page faults | 此程序的主要内存页错误发生的次数。 所谓的主要内存页错误是指某一内存页己经詈换到 SWAP 分区中，又被其他程序使用过，该页的内容必须从 SWAP 分区里再读出来才能使用 |
| Minor (reclaiming a frame) page faults | 此程序的次要内存页错误发生的次数。 所谓的次要内存页错误是指某一内存页虽然己经詈换到 SWAP 中，但尚未被其他程序使用。此时该页的内容并未 被破坏，不必从 SWAP 分区里读出来即可直接使用 |
| Swaps | 此程序被交换到 SWAP 分区的次数 |
| Involuntary context switches | 此程序被强迫中断（如 CPU 时间耗尽）的次数 |
| Voluntary context switches | 此程序自愿中断（I/O 执行完毕，磁碟读取完成等）的次数 |
| File system inputs | 此程序所输入的文件数 |
| File system outputs | 此程序所输出的文件数 |
| Socket messages received | 此程序所收到的 Socket Message |
| Socket messages sent | 此程序所送出的 Socket Message |
| Signals delivered | 此程序所收到的信号数 |
| Exit status | 命令退出状态 |
times()函数用于获取当前进程时间。
#include <sys/times.h>
clock_t times(struct tms *buf);参数 buf： struct tms 结构体指针。
struct tms {
clock_t tms_utime; /* user time, 进程的用户 CPU 时间, tms_utime 个系统节拍数 */
clock_t tms_stime; /* system time, 进程的系统 CPU 时间, tms_stime 个系统节拍数 */
clock_t tms_cutime; /* user time of children, 已死掉子进程的 tms_utime + tms_cutime 时间总和 */
clock_t tms_cstime; /* system time of children, 已死掉子进程的 tms_stime + tms_cstime 时间总和 */
};
返回值： 返回值类型为 clock_t（实质是 long 类型）， 调用成功情况下，将返回从过去任意的一个时间点（譬如系统启动时间） 所经过的时钟滴答数（系统节拍数）， 将(节拍数 / 节拍率)便可得到秒数，返回值可能会超过 clock_t 所能表示的范围（溢出）； 调用失败返回-1，并设置 errno。
库函数 clock()提供了一个更为简单的方式用于进程时间，它的返回值描述了进程使用的总的 CPU 时间（也就是进程时间，包括用户 CPU 时间和系统 CPU 时间）
#include <time.h>
clock_t clock(void);返回值： 返回值是到目前为止程序的进程时间，为 clock_t 类型。 clock()的返回值是系统节拍数，如果想要获得秒数，请除以 CLOCKS_PER_SEC。 如果返回的进程时间不可用或其值无法表示，则该返回值是-1。
函数"clock_gettime"是基于Linux C语言的时间函数,用于计算程序运行的时间。
#include <time.h>
int clock_gettime(clockid_t clk_id,struct timespec *tp);参数 clk_id : 检索和设置的clk_id指定的时钟时间。
| CLOCK_MONOTONIC | 从系统启动这一刻起开始计时,不受系统时间被用户改变的影响 |
| CLOCK_PROCESS_CPUTIME_ID | 本进程到当前代码系统CPU花费的时间 |
| CLOCK_THREAD_CPUTIME_ID | 本线程到当前代码系统CPU花费的时间 |
参数 tp：
struct timespec
{
time_t tv_sec; /* 秒*/
long tv_nsec; /* 纳秒*/
};返回值：成功返回0，出错返回-1，并设置错误码。
rand()函数用于获取随机数。
#include <stdlib.h>
int rand(void);返回值： 返回一个介于 0 到 RAND_MAX（包含）之间的值，也就是数学上的[0, RAND_MAX]。
使用 srand()函数为 rand()函数设置随机数种子。
#include <stdlib.h>
void srand(unsigned int seed);参数 seed：随机数种子，一般将当前时间作为随机数种子赋值给参数 seed，譬如 time(NULL)。
random()函数使用一个非线性加法反馈随机数生成器，它使用一个长度为31个长整数的默认表来返回从0到RAND_MAX范围内的连续伪随机数。这个随机数发生器的周期非常大，大约是16 *((2^31)- 1)。
#include <stdlib.h>
long int random(void);使用 srandom()函数为 random()函数设置随机数种子。
#include <stdlib.h>
void srandom(unsigned int seed);参数 seed：随机数种子。
#include <stdlib.h>
char *initstate(unsigned int seed, char *state, size_t n);
initstate()函数允许一个状态数组状态被random()初始化使用。initstate()使用状态数组n的大小来决定它应该使用的随机数生成器的复杂程度—状态数组越大，随机数就越好。Seed是初始化的种子，它指定随机数序列的起点，并提供在同一点重新启动。
#include <stdlib.h>
char *setstate(char *state);
setstate()函数改变random()函数使用的状态数组。状态数组状态用于随机数生成，直到下一次调用initstate()或setstate()。状态必须首先使用initstate()进行初始化，或者是之前调用setstate()的结果。
秒级休眠函数。
#include <unistd.h>
unsigned int sleep(unsigned int seconds);参数 seconds： 休眠时长，以秒为单位。
返回值： 如果休眠时长为参数 seconds 所指定的秒数，则返回 0；若被信号中断则返回剩余的秒数。
微秒级休眠函数。
#include <unistd.h>
int usleep(useconds_t usec);参数 usec： 休眠时长，以微秒为单位。
返回值： 成功返回 0；失败返回-1，并设置 errno。
nanosleep()是一个 Linux 系统调用，支持纳秒级时长设置。
#include <time.h>
int nanosleep(const struct timespec *req, struct timespec *rem);参数 req： struct timespec 结构体指针，用于设置休眠时间长度，可精确到纳秒级别。
struct timespec {
time_t tv_sec; // seconds
long tv_nsec; // and nanoseconds
};参数 rem： struct timespec 结构体指针，保存将剩余时间，也可设置 NULL。
返回值： 在成功休眠达到请求的时间间隔后， nanosleep()返回 0； 如果中途被信号中断或遇到错误，则返回-1， 并将剩余时间记录在参数 rem 指向的 struct timespec 结构体变量中，还会设置 errno 标识错误类型。
分配内存。
#include <stdlib.h>
void *malloc(size_t size);参数 size：需要分配的内存大小，以字节为单位。
返回值：返回值为 void *类型，如果申请分配内存成功，将返回一个指向该段内存的指针。如果分配内存失败（譬如系统堆内存不足） 将返回 NULL，如果参数 size 为 0，返回值也是 NULL。
释放内存。
#include <stdlib.h>
void free(void *ptr);参数 ptr： 指向需要被释放的堆内存对应的指针。
返回值： 无返回值。
分配内存并初始化为0。
#include <stdlib.h>
void *calloc(size_t nmemb, size_t size);参数 nmemb：数量
参数 size：大小
返回值： 分配成功返回指向该内存的地址，失败则返回 NULL。
注：calloc()与 malloc()的一个重要区别是： calloc()在动态分配完内存后，自动初始化该内存空间为零，而malloc()不初始化。
posix_memalign()函数用于在堆上分配 size 个字节大小的对齐内存空间， 将*memptr 指向分配的空间。
#include <stdlib.h>
int posix_memalign(void **memptr, size_t alignment, size_t size);参数 memptr： void **类型的指针，内存申请成功后会将分配的内存地址存放在*memptr 中。
参数 alignment： 设置内存对其的字节数， alignment 必须是 2 的幂次方（譬如 2^4、 2^5、 2^8 等），同时也要是 sizeof(void *)的整数倍。
参数 size： 设置分配的内存大小，以字节为单位，如果参数 size 等于 0，那么*memptr 中的值是 NULL。
返回值： 成功将返回 0；失败返回非 0 值。
aligned_alloc()函数用于分配 size 个字节大小的内存空间， 返回指向该空间的指针。
#include <stdlib.h>
void *aligned_alloc(size_t alignment, size_t size);参数 alignment： 用于设置对齐字节大小， alignment 必须是 2 的幂次方（譬如 2^4、 2^5、 2^8 等）。
参数 size： 设置分配的内存大小，以字节为单位。参数 size 必须是参数 alignment 的整数倍。
返回值： 成功将返回内存空间的指针，内存空间的起始地址是参数 alignment 的整数倍；失败返回 NULL。
分配一个由size指定大小，地址是boundary的倍数的内存块。参数boundary必须是2的幂！函数memalign可以分配较大的内存块，并且可以为返回的地址指定粒度。
注：已经过时了，并不提倡使用！
#include <malloc.h>
void *memalign(size_t alignment, size_t size);
参数 alignment：用于设置对齐字节大小， alignment 必须是 2 的幂次方（譬如 2^4、 2^5、 2^8 等）。
参数 size： 设置分配的内存大小，以字节为单位。参数 size 必须是参数 alignment 的整数倍。
返回值： 成功将返回内存空间的指针，内存空间的起始地址是参数 alignment 的整数倍；失败返回 NULL。
分配 size 个字节大小的内存空间，返回指向该内存空间的指针， 内存空间的地址是页大小
（pagesize） 的倍数。
注：已经过时了，并不提倡使用！
#include <stdlib.h>
void *valloc(size_t size);参数 size： 设置分配的内存大小。
返回值： 成功将返回内存空间的指针。
注：valloc()与 memalign()类似，只不过 valloc()函数内部实现中，使用了页大小作为对齐的长度。
pvalloc 与 valloc 相似，不过将分配的空间大小扩展为页大小的倍数。
注：已经过时了，并不提倡使用！
#include <malloc.h>
void *pvalloc(size_t size);
参数 size： 设置分配的内存大小。
返回值： 成功将返回内存空间的指针。
可用来实现延时和定时的功能。
#include <sys/time.h>
int setitimer(int which, const struct itimerval *new_value,
struct itimerval *old_value);参数 which：定时器类型
| 值 | 说明 | 信号 |
| ITIMER_REAL | 以系统真实的时间来计算 | SIGALRM |
| ITIMER_VIRTUAL | 以该进程在用户态下花费的时间来计算 | SIGVTALRM |
| ITIMER_PROF | 以该进程在用户态下和内核态下所费的时间来计算 | SIGPROF |
参数 new_value：用来对计时器进行设置，it_interval为计时间隔，it_value为延时时长。
struct itimerval {
struct timeval it_interval; /* next value */
struct timeval it_value; /* current value */
};
struct timeval {
time_t tv_sec; /* seconds */
suseconds_t tv_usec; /* microseconds */
};参数 old_value：old_value通常设置为NULL，用来存储上一次setitimer调用时设置的new_value值。
返回值：成功返回0，出错返回-1，并设置错误码。
获取或定时器的值。
#include <sys/time.h>
int getitimer(int which, struct itimerval *curr_value);参数 which：定时器类型
参数 curr_value：获取指定类型定时器的值。
返回值：成功返回0，出错返回-1，并设置错误码。