C++ sleep相关延时函数

秒相关单位进制转换

[sleep() 函数：](#sleep() 函数：)

[usleep() 函数：](#usleep() 函数：)

[nanosleep() 函数：](#nanosleep() 函数：)

C++11及以后版本的std::this_thread::sleep_for()：

秒相关单位进制转换

秒（second, s）是国际单位制（SI）中时间的基本单位。以下是一些更小的时间单位与秒之间的转换关系，这些转换类似于进制转换，但实际上是以十进制为基础的比例关系：

毫秒（millisecond, ms）: 1毫秒等于1秒的千分之一，即1 ms = 1/1000 s 或者 1000 ms = 1 s。
微秒（microsecond, μs）: 1微秒等于1秒的百万分之一，即1 μs = 1/1,000,000 s 或者 1,000,000 μs = 1 s。
纳秒（nanosecond, ns）: 1纳秒等于1秒的十亿分之一，即1 ns = 1/1,000,000,000 s 或者 1,000,000,000 ns = 1 s。
皮秒（picosecond, ps）: 1皮秒等于1秒的一万亿分之一，即1 ps = 1/1,000,000,000,000 s 或者 1,000,000,000,000 ps = 1 s。

总结起来，这些更小的时间单位之间的换算遵循10的幂次规律：

每前进一位，时间单位缩小1000倍。
从秒到毫秒，缩小了1000倍（10^3）。
从毫秒到微秒，再次缩小了1000倍（10^3）。
从微秒到纳秒，又缩小了1000倍（10^3）。
从纳秒到皮秒，继续缩小1000倍（10^3）。

在计算机编程中，sleep及其相关的延时函数是用于暂停程序执行一段时间的函数。以下是它们的讲解：

sleep() 函数：

C语言中的sleep()函数（在unistd.h头文件中定义）用于让当前进程（或线程）暂停执行指定的秒数。例如：
cpp 复制代码
```
#include <unistd.h>
sleep(5); // 暂停执行5秒
```
注意，sleep()函数精度通常以秒为单位，且它会释放CPU，让其他进程有机会运行。

示例：

cpp 复制代码

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

int main() {
    printf("程序开始执行...\n");
    
    // 暂停5秒
    sleep(5);

    printf("经过5秒后，程序继续执行...\n");

    return 0;
}

在这个例子中，当程序执行到 sleep(5) 语句时，程序会暂停5秒，然后继续执行后续的 printf 语句。

usleep() 函数：

usleep()同样是C语言中的一个延时函数，但它提供微秒级别的暂停。同样在unistd.h头文件中定义，其原型为：
cpp 复制代码
```
#include <unistd.h>
unsigned int usleep(useconds_t useconds);
```
参数useconds是一个无符号整型数，表示暂停的微秒数（1秒=1,000,000微秒）。
虽然usleep()提供了更高的时间分辨率，但在某些系统（如Windows）中并不支持，且在POSIX标准中已被弃用，推荐使用nanosleep()函数替代。
示例：
cpp 复制代码
```
#include <unistd.h>
#include <stdio.h>

int main() {
    printf("程序开始执行...\n");

    // 暂停500毫秒（500,000微秒）
    usleep(500000);

    printf("经过500毫秒后，程序继续执行...\n");

    return 0;
}
```
在上述示例中，usleep(500000)会让程序暂停500毫秒，然后继续执行。需要注意的是，usleep()在一些系统中（比如Windows）可能不可用或已经被弃用，建议使用nanosleep()或者其他系统的高精度延时函数。

nanosleep() 函数：

nanosleep()函数提供纳秒级别的延时，相比usleep()具有更高的精度。在POSIX兼容的系统中定义，其原型如下：
cpp 复制代码
```
#include <time.h>
int nanosleep(const struct timespec *req, struct timespec *rem);
```
参数req指向一个timespec结构体，包含了要求的纳秒级延迟时间，而rem用于存储剩余的未休眠时间（可选）。

示例：

cpp 复制代码

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

void nano_sleep_example() {
    // 创建一个timespec结构体，指定纳秒级的休眠时间
    struct timespec sleep_time;
    sleep_time.tv_sec = 1; // 秒数部分，这里是1秒
    sleep_time.tv_nsec = 500000000; // 纳秒数部分，这里是5亿纳秒（即0.5秒）

    // 调用nanosleep函数
    while (nanosleep(&sleep_time, NULL) == -1 && errno == EINTR) {
        // 如果nanosleep被信号中断，重新调用自身直到完成休眠
        printf("nanosleep was interrupted by a signal, retrying...\n");
        continue;
    }

    if (errno != 0 && errno != EINTR) {
        perror("An unexpected error occurred during nanosleep()");
    } else {
        printf("Sleep completed with nanosleep().\n");
    }
}

int main() {
    nano_sleep_example();
    return 0;
}

在此例中，我们首先定义了一个timespec结构体，其中包含了想要休眠的时间（1.5秒）。然后调用nanosleep()函数，如果在休眠期间收到信号导致函数提前返回，错误码errno会被设置为EINTR，这时循环会重新调用nanosleep()直到指定的时间完全过去。

C++11及以后版本的std::this_thread::sleep_for()：

C++11引入了线程库，其中std::this_thread::sleep_for()方法可以用来暂停当前线程执行，其精度取决于编译器和系统实现，可以达到微秒甚至纳秒级别。例如：
cpp 复制代码
```
#include <chrono>
#include <thread>
std::this_thread::sleep_for(std::chrono::milliseconds(500)); // 暂停500毫秒
```

示例：

cpp 复制代码

#include <iostream>
#include <chrono>
#include <thread>

void this_thread_sleep_example() {
    // 使用C++11的chrono库指定休眠时间，这里休眠1.5秒
    std::this_thread::sleep_for(std::chrono::seconds(1) + std::chrono::milliseconds(500));

    std::cout << "Sleep completed with std::this_thread::sleep_for().\n";
}

int main() {
    this_thread_sleep_example();
    return 0;
}

在C++11的例子中，我们使用了std::chrono库来创建一个表示1.5秒的持续时间对象，并将其传递给std::this_thread::sleep_for()函数。这样就能在当前线程上精确地休眠指定的时长。std::this_thread::sleep_for()函数的精度依赖于系统实现，但通常可以达到微秒甚至纳秒级别。

以上函数在多线程环境下使用时应注意同步问题，确保在等待期间不会影响到其他关键资源的访问。另外，由于系统调度的不确定性，实际暂停的时间可能会比指定的时间稍长。