c++多线程基础2(命名空间 this_thread)

整理自：zh.cppreference.com/w/cpp/thread

std::this_thread::yield：

定义于头文件 <thread>

函数原型：void yield() noexcept;

此函数的准确性为依赖于实现，特别是使用中的 OS 调度器机制和系统状态。例如，先进先出实时调度器（ Linux 的 SCHED_FIFO ）将悬挂当前线程并将它放到准备运行的同优先级线程的队列尾（而若无其他线程在同优先级，则 yield 无效果）

代码：

#include <iostream>
#include <thread>
#include <chrono>
using namespace std;

void little_sleep(std::chrono::milliseconds us) {
    auto start = std::chrono::high_resolution_clock::now();
    auto end = start + us;
    do { 
        std::this_thread::yield();//让出当前时间片
    }while(std::chrono::high_resolution_clock::now() < end);
}

int main(void) {
    auto start = std::chrono::high_resolution_clock::now();//获取当前时间

    little_sleep(std::chrono::milliseconds(100));

    auto elapsed = std::chrono::high_resolution_clock::now() - start;//计算执行 little_sleep 所用时间

    cout << "waited fo "
            << std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count() //将 elapsed 时间周期转化为 milliseconds 并输出
            << " milliseconds
";

// 输出：
// waited fo 100 milliseconds

    return 0;
}

std::this_thread::get_id：

定义于头文件 <thread>

函数原型：std::thread::id get_id() noexcept;

得到当前线程的 id

代码：

#include <iostream>
#include <thread>
#include <chrono>
#include <mutex>
using namespace std;

std::mutex g_display_mutex;

void foo() {
    auto this_id = std::this_thread::get_id();

    g_display_mutex.lock();
    cout << "thread" << this_id << " sleeping..." << endl;
    g_display_mutex.unlock();

    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main(void) {
    std::thread t1(foo);
    std::thread t2(foo);

    t1.join();
    t2.join();

// 输出：
// thread2 sleeping...
// thread3 sleeping...

    return 0;
}

std::this_thread::sleep_for：

定义于头文件 <thread>

函数原型：

template< class Rep, class Period >
void sleep_for( const std::chrono::duration<Rep, Period>& sleep_duration );

阻塞当前线程执行，以至少为指定的 sleep_duration 。

此函数可能阻塞长于 sleep_duration ，因为调度或资源争议延迟。

标准库建议用稳定时钟度量时长。若实现用系统时间代替，则等待时间亦可能对始终调节敏感

异常：任何时钟、 time_point 或 duration 在执行间抛出的异常（标准库提供的时钟、时间点和时长决不抛出）

代码：

#include <iostream>
#include <chrono>
#include <thread>
using namespace std;

int main(void) {
    cout << "hello waiter" << endl;

    auto start = std::chrono::high_resolution_clock::now();
    std::this_thread::sleep_for(std::chrono::seconds(2));
    auto end = std::chrono::high_resolution_clock::now();

    std::chrono::duration<double, std::milli> elapsed = end - start;
    cout << "waited " << elapsed.count() << " ms" << endl;

// 输出：
// hello waiter
// waited 2001.44 ms

    return 0;
}

std::this_thread::sleep_until：

定义于头文件 <thread>

template< class Clock, class Duration >
void sleep_until( const std::chrono::time_point<Clock,Duration>& sleep_time );

阻塞当前线程，直至抵达指定的 sleep_time 。

使用联倾向于 sleep_time 的时钟，这表示时钟调节有影响。从而在调用时间点后，阻塞的时长可能小于，但不会多于 sleep_time - Clock::now() 。函数亦可能阻塞长于抵达 sleep_time 之后，由于调度或资源争议延迟

代码：

#include <iostream>
#include <chrono>
#include <thread>
using namespace std;

int main(void) {
    auto start = std::chrono::high_resolution_clock::now();
    std::this_thread::sleep_until(start + std::chrono::seconds(2));
    auto end = std::chrono::high_resolution_clock::now();

    std::chrono::duration<double, std::milli> elapsed = end - start;
    cout << "waited " << elapsed.count() << " ms" << endl;

// 输出：
// waited 2001.42 ms

    return 0;
}