c++11新特性多线程操作实战

int main()
{
  thread t1(Test1);
  t1.join();
  thread t2(Test2);
  t2.join();
  thread t3 = t1;
  thread t4(t1);
  thread t5 = std::move(t1);
  thread t6(std::move(t1));
  return 0;
}

thread(const thread&) = delete;
thread& operator=(const thread&) = delete;

class Task
{
public:
  Task(){}
  void Task1() {}
  void Task2() {}
private:
};

int main()
{
  Task task;
  thread t3(&Task::Task1, &task);
  t3.join();
  return 0;
}

#include <iostream>
#include <chrono>
#include <thread>
 
// 建议其他线程运行一小段时间的“忙睡眠”
void little_sleep(std::chrono::microseconds 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()
{
  auto start = std::chrono::high_resolution_clock::now();
 
  little_sleep(std::chrono::microseconds(100));
 
  auto elapsed = std::chrono::high_resolution_clock::now() - start;
  std::cout << "waited for "
       << std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count()
       << " microseconds\n";
}

std::thread::id this_id = std::this_thread::get_id();

std::this_thread::sleep_for(2s);
std::this_thread::sleep_for(std::chrono::seconds(1));

using std::chrono::system_clock;
time_t tt = system_clock::to_time_t(system_clock::now());
struct std::tm *ptm = localtime(&tt);
 std::this_thread::sleep_until(system_clock::from_time_t(mktime(ptm)));

mutex mtx;

int gNum = 0;
void Test1()
{
  mtx.lock();
  for(int n = 0; n < 5; ++n)
    gNum++;
  mtx.unlock();
}

void Test2()
{
  std::cout << "gNum = " << gNum << std::endl;
}

int main()
{
  thread t1(Test1);
  t1.join();
  thread t2(Test2);
  t2.join();
  return 0;
}

void Test1()
{
  std::lock_guard<std::mutex> lg(mtx);
  for(int n = 0; n < 5; ++n)
  {
    gNum++;
    std::cout << "gNum = " << gNum << std::endl;
  }
}
int main()
{
  thread t1(Test1);
  thread t2(Test1);
  t1.join();
  t2.join();
  return 0;
}