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());
 
     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\n";
 
 // 输出：
 // waited fo 100 milliseconds
 
     return ;
 }

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());
 }
 
 int main(void) {
     std::thread t1(foo);
     std::thread t2(foo);
 
     t1.join();
     t2.join();
 
 // 输出：
 // thread2 sleeping...
 // thread3 sleeping...
 
     return ;
 }

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());
     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 ;
 }

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());
     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 ;
 }