std::this_thread::yield：　当前线程放弃执行，操作系统调度另一线程继续执行。即当前线程将未使用完的“CPU时间片”让给其他线程使用，等其他线程使用完后再与其他线程一起竞争"CPU"。
std::this_thread::sleep_for：　表示当前线程休眠一段时间，休眠期间不与其他线程竞争CPU，根据线程需求，等待若干时间。

this_thread 包装了一组可以访问当前线程信息的函数

1、get_id()      获取当前线程的id。

// thread::get_id / this_thread::get_id
#include <iostream>       // std::cout
#include <thread>         // std::thread, std::thread::id, std::this_thread::get_id
#include <chrono>         // std::chrono::seconds
 
std::thread::id main_thread_id = std::this_thread::get_id();
 
void is_main_thread() {
  if ( main_thread_id == std::this_thread::get_id() )
    std::cout << "This is the main thread.\n";
  else
    std::cout << "This is not the main thread.\n";
}
 
int main() 
{
  is_main_thread();
  std::thread th (is_main_thread);
  th.join();
}

输出结果

This is the main thread.
This is not the main thread.

2、yield()
调用线程放弃执行，回到准备状态，重新分配cpu资源。所以调用该方法后，可能执行其他线程，也可能还是执行该线程

// this_thread::yield example
#include <iostream>       // std::cout
#include <thread>         // std::thread, std::this_thread::yield
#include <atomic>         // std::atomic
 
std::atomic<bool> ready (false);
 
void count1m(int id) {
  while (!ready) {             // wait until main() sets ready...
    std::this_thread::yield();
  }
  for (volatile int i=0; i<1000000; ++i) {}
  std::cout << id;
}
 
int main ()
{
  std::thread threads[10];
  std::cout << "race of 10 threads that count to 1 million:\n";
  for (int i=0; i<10; ++i) threads[i]=std::thread(count1m,i);
  ready = true;               // go!
  for (auto& th : threads) th.join();
  std::cout << '\n';
 
  return 0;
}

输出结果

race of 10 threads that count to 1 million...
6189370542

3、template <class Clock, class Duration>
       void sleep_until (const chrono::time_point<Clock,Duration>& abs_time);
阻塞调用线程，一直到指定事件

// this_thread::sleep_for example
#include <iostream>       // std::cout
#include <iomanip>        // std::put_time
#include <thread>         // std::this_thread::sleep_until
#include <chrono>         // std::chrono::system_clock
#include <ctime>          // std::time_t, std::tm, std::localtime, std::mktime
 
int main() 
{
  using std::chrono::system_clock;
  std::time_t tt = system_clock::to_time_t (system_clock::now());
 
  struct std::tm * ptm = std::localtime(&tt);
  std::cout << "Current time: " << std::put_time(ptm,"%X") << '\n';
 
  std::cout << "Waiting for the next minute to begin...\n";
  ++ptm->tm_min; ptm->tm_sec=0;
  std::this_thread::sleep_until (system_clock::from_time_t (mktime(ptm)));
 
  std::cout << std::put_time(ptm,"%X") << " reached!\n";
 
  return 0;
}

输出结果

Current time: 11:52:36
Waiting for the next minute to begin...
11:53:00 reached!

4、template <class Rep, class Period>
       void sleep_for (const chrono::duration<Rep,Period>& rel_time);
阻塞调用线程，一直到指定时间段后。

// this_thread::sleep_for example
#include <iostream>       // std::cout
#include <thread>         // std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds
 
int main() 
{
  std::cout << "countdown:\n";
  for (int i=10; i>0; --i) {
    std::cout << i << '\n';
    std::this_thread::sleep_for (std::chrono::seconds(1));
  }
  std::cout << "Lift off!\n";
 
  return 0;
}

输出结果

countdown:
10
9
8
7
6
5
4
3
2
1
Lift off!

参考链接:

https://en.cppreference.com/w/cpp/thread/sleep_for

https://blog.csdn.net/u012085988/article/details/17225325

https://blog.csdn.net/Sandy_WYM_/article/details/83538635

std::this_thread::yield：　当前线程放弃执行，操作系统调度另一线程继续执行。即当前线程将未使用完的“CPU时间片”让给其他线程使用，等其他线程使用完后再与其他线程一起竞争"CPU"。
std::this_thread::sleep_for：　表示当前线程休眠一段时间，休眠期间不与其他线程竞争CPU，根据线程需求，等待若干时间。

两者具有相似的作用，但使用目的不同。例如以下两个函数：

#include<thread>
#include<mutex>
#include<iostream>
std::mutex mtx;
bool g_flag = false;
void F1(int n)
{
  while (true)
  {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    n++;
    if(n == 10){
      mtx.lock();
      g_flag = true;
      mtx.unlock();
    }else
      std::cout<<"F1 n: "<<n<<std::endl;
  }
}

void F2(int& n)
{
  while (true)
  {
    mtx.lock();
    bool flag = g_flag;
    mtx.unlock();
    if( flag )
    {
      n++;
      std::cout<<"F2 n: "<<n<<std::endl;
    }else
      std::this_thread::yield();
  }
}
int main(){
  int n = 0;
  std::thread t1(F1, n), t2(F2, std::ref(n));
  t1.join();
  t2.join();
｝

F1线程函数循环体内，每隔１秒钟执行一次操作。

F2线程函数循环体内若标志位被置位则执行一次操作，否则放弃当前线程，让出未用完的CPU时间片，等其他线程使用完后再一起竞争CPU时间，若循环体内不使用yield，则该线程立即与其他线程竞争CPU时间，像此类线程频繁地竞争CPU时间从而影响程序性能。

std::this_thread::sleep_for

Defined in header <thread> - 定义于头文件 <thread>

1. std::this_thread::sleep_for

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

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

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

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

Sleep for time span - 睡眠一段时间

Blocks execution of the calling thread during the span of time specified by rel_time.
在 rel_time 指定的时间段内阻止调用线程的执行。

The execution of the current thread is stopped until at least rel_time has passed from now. Other threads continue their execution.
当前线程的执行将停止，直到从现在起至少经过 rel_time 为止。其他线程继续执行。

2. Parameters

rel_time
The time span after which the calling thread shall resume its execution.
调用线程应在其后恢复执行的时间间隔。

Note that multi-threading management operations may cause certain delays beyond this.
请注意，多线程管理操作可能会导致某些延迟。

duration is an object that represents a specific relative time.
持续时间是代表特定相对时间的对象。

要睡眠的时长。

resume [rɪ'zjuːm]：n. 简历 v. 继续，重返

3. Return value

none

4. Examples

4.1 std::this_thread::sleep_for

//============================================================================
// Name        : std::this_thread::sleep_for
// Author      : Yongqiang Cheng
// Version     : Version 1.0.0
// Copyright   : Copyright (c) 2019 Yongqiang Cheng
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>       // std::cout, std::endl
#include <thread>         // std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds

int main()
{
	std::cout << "countdown:\n";
	for (int i = 10; i > 0; --i)
	{
		std::cout << i << std::endl;
		std::this_thread::sleep_for(std::chrono::seconds(1));
	}
	std::cout << "Lift off!\n";

	return 0;
}

Output (after 10 seconds):

countdown:
10
9
8
7
6
5
4
3
2
1
Lift off!

4.2 std::this_thread::sleep_for

//============================================================================
// Name        : std::this_thread::sleep_for
// Author      : Yongqiang Cheng
// Version     : Version 1.0.0
// Copyright   : Copyright (c) 2019 Yongqiang Cheng
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>       // std::cout, std::endl
#include <thread>         // std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds

int main()
{
	using namespace std::chrono_literals;

	std::cout << "Hello waiter\n" << std::flush;

    // C++14
	auto start = std::chrono::high_resolution_clock::now();
	std::this_thread::sleep_for(2s);
	auto end = std::chrono::high_resolution_clock::now();

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

	return 0;
}

10:22:39 **** Incremental Build of configuration Debug for project hello_world ****
make all 
Building file: ../src/hello_world.cpp
Invoking: GCC C++ Compiler
g++ -std=c++1y -O0 -g3 -Wall -c -fmessage-length=0 -MMD -MP -MF"src/hello_world.d" -MT"src/hello_world.o" -o "src/hello_world.o" "../src/hello_world.cpp"
Finished building: ../src/hello_world.cpp
 
Building target: hello_world
Invoking: GCC C++ Linker
g++  -o "hello_world"  ./src/hello_world.o   -lpthread
Finished building target: hello_world
 

10:22:40 Build Finished (took 895ms)

Hello waiter
Waited 2000.06 ms

7. Exception safety - 异常安全性

If the type of rel_time never throws exceptions (like the instantiations of duration in header <chrono>), this function never throws exceptions (no-throw guarantee).
如果 rel_time 的类型从不抛出异常 (如头文件 <chrono> 中的 duration` 实例化)，则此函数从不抛出异常 (无抛出保证)。

assignment [ə'saɪnmənt]：n. 任务，布置，赋值

References

http://www.cplusplus.com/reference/thread/this_thread/sleep_for/
https://en.cppreference.com/w/cpp/thread/sleep_for