std::this

本实例主要是包含了一组操作当前线程的函数，目前包含四个处理函数。

1. 处理函数

1.1 get_id

// thread::get_id / this_thread::get_id
#include        // std::cout
#include          // std::thread, std::thread::id, std::this_thread::get_id
#include          // 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();
}


Output:
This is the main thread.
This is not the main thread.

1.2 sleep_for进程睡眠一段时间

// this_thread::sleep_for example
#include        // std::cout, std::endl
#include          // std::this_thread::sleep_for
#include          // 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!

1.3 sleep_until睡眠到一个绝对时间

// this_thread::sleep_for example
#include        // std::cout
#include         // std::put_time
#include          // std::this_thread::sleep_until
#include          // std::chrono::system_clock
#include           // 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;
}


Output (after an avg. of 30 seconds):
Current time: 11:52:36
Waiting for the next minute to begin...
11:53:00 reached!

1.4 yield进程直接调出

// this_thread::yield example
#include        // std::cout
#include          // std::thread, std::this_thread::yield
#include          // std::atomic

std::atomic 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;
}


Possible output (last line may vary):
race of 10 threads that count to 1 million...
6189370542