漫话C++0x（五）—- thread, mutex, condition_variable

漫话C++0x（五）—- thread, mutex, condition_variable

 

   熟悉C++98的朋友，应该都知道，在C++98中没有thread, mutex, condition_variable这些与concurrency相关的特性支持，如果需要写多线程相关程序，都要借助于不同平台上各自提供的api，这样带来的问题就是程序的跨平台移植性比较差，经常要用一大堆的#ifdef WIN32类似的宏来区分不同的平台，搞得程序很难看。C++0x最原始的初衷之一就是为了让C++的功能更加强大，更加方便使用。现如今硬件如此发达，concurrency在程序设计中已经是司空见惯的事情了，如果C++再不支持这些concurrency相关的特性，就真的out了。现在，C++程序员的福音到了，C++0x提供了对thread, mutex, condition_variable这些concurrency相关特性的支持，以后多线程这一块的代码可以完全跨平台了，而且由于C++0x封装的都比较好，代码写起来也十分简洁。下面开始介绍今天的内容。

• 1. thread

      写过多线程程序的朋友，相信对thread本身都不会陌生，这里不对thread本身做太多的说明，以介绍C++0x中提供的thread的用法为主。请大家先看下面的例子：

  #include < iostream>
  #include < string>
  #include < thread>
   
  class Printer
  {
  public:
      void Print(int id, std::string& name)
      {   
          std::cout < < "id=" << id << ", name=" << name;
      }   
  };
   
  void Hello()
  {
      std::cout << "hello world" << std::endl;
  }
   
  int main()
  {
      Printer p;
      int id = 1;
      std::string name("xiao5ge");
   
      std::thread t1(&Printer::Print, p, id, name);
      std::thread t2(std::bind(&Printer::Print, p, id, name));
      std::thread t3([&]{ p.Print(id, name); }); 
      std::thread t4(Hello);
   
      t4.join();
      t3.join();
      t2.join();
      t1.join();
  }

  
  

  下面我们来通过分析上面的例子，来说明一下thread的用法。上面的t1-t4的四个例子，分别是thread的四种构造方式，我们一一来介绍一下：

  • (1)这种方式是通过变参数模板实现的，第一个参数是线程入口函数的地址，后面的参数按函数调用时的参数顺序传入。这里需要说明两点：一是变参模板也是C++0x新增的特性，将会在后面的文章中介绍;二是，类成员函数的第一个参数永远是this，所以这里第一个参数放的是对象本身。
  • (2)这种方式是传入一个std::function对象，bind/function在前一篇中有介绍，不熟悉的朋友可以先看一下C++0x系列的第四篇。
  • (3)这种方式是传入一个lambda表达式，也即一个closure，是比较常用的方式。关于lambda也在上一篇中有介绍。
  • (4)这种方式是最简单，最常用的方式，直接传入一个函数，写过多线程程序的朋友应该对这种方式最为熟悉。

      上面介绍了C++0x thread的基本用法，下面需要再补充几点使用过程需要注意的事项：

  • （1）如果入口函数的参数是以引用或指针形式传入的，需要使用者保证在线程运行过程中，这些参数一直是有效的。同时，如果有多个线程会访问或者修改这些变量，需要使用者做好同步，保证一致性。
  • （2）关于上面提到的几种构造方式，简单的直接用4，复杂的推荐的选择顺序：1->3->2，即变参模板方式->lambda方式->bind方式
  • （3）通常需要等子线程运行完，主线程才退出，所以在主线程中通常需要调各子线程的join()。
• 2. mutex

      mutex实现的是“互斥锁”的语义，在多线程的程序中，经常需要通过锁的机制来保证数据的一致性，C++0x提供了下面四种语义的mutex:

  • (1) std::mutex: 普通的互斥锁，不能递归使用
  • (2) std::timed_mutex：带超时的互斥锁，不能递归使用
  • (3) std::recursive_mutex：递归互斥锁
  • (3) std::recursive_timed_mutex：带超时的递归互斥锁

      关于mutex的使用，我们通常建议使用RAII(Resource Acquisition is Initialization)的方式，即在构造的时候lock, 析构的时候unlock, 不建议直接显式的lock/unlock，因为这样比较容易出错。因此，C++0x也提供了两个工具类std::lock_guard和 std::unique_lock来辅助我们使用mutex，下面我们通过例子来看一下具体的使用：

  #include < mutex>
   
  // global vars
  int data = 0;
  std::mutex data_mutex;
   
  // thread 1
  {
      std::lock_guard< std::mutex> locker(data_mutex);
      data = 1;
  }
   
  // thread 2
  {
      std::lock_guard< std::mutex> locker(data_mutex);
      data = 2;
  }

  
  

   从上面的例子，相信大家可以对mutex的基本使用方法都应该比较清楚了，由于mutex本身就比较简单，这里不再赘言。说一下 std::unique_lock和std::lock_guard的区别，std::lock_guard只允许RAII方式的使用，而 std::unique_lock可以在构造之后调用lock/unlock, 更加灵活一些，但使用的时候出错的机率也更大一些，所以如果没有什么特殊的需求，通常推荐尽量使用std::lock_guard.

  • 3. condition_variable

        关于condition_variable，它的语义是今天讲的三个内容里面相对复杂一些的，我在之前也写过一篇关于它的文章，不熟悉的朋友可以先阅读一下《条件变量(Condition Variable)详解》这篇文章，先了解一下条件变量，以方便理解后面的内容。我们知道，条件变量主要是用在多线程之间修改了shared_data之后的相互通信，由于条件变量在多线程编程中非常有用，所以C++0x也添加了对条件变量的支持，下面是C++0x提供的两种不同类型的条件变量：

  • （1）condition_variable: 用在std::unique_lock< std::mutex>上wait, 比较高效。
  • （2）condition_variable_any: 可以用在任意mutex上wait, 比较灵活，但效率比condition_variable差一些。

      下面我们通过例子来看看，条件变量在C++0x中的使用方式：

  // global
  std::atomic< bool> is_finish(false);
  std::mutex finish_mutex;
  std::condition_variable finish_cond;
   
  // thread 1
  {
      std::unique< std::mutex> locker(finish_mutex);
   
      // 1. loop wait
      while (!is_finish)
      {   
          finish_cond.wait(locker);
      }   
   
      // 2. wait until prediction is true, loop inside
      finish_cond.wait(locker, []{ return is_finish; }); 
   
      // 3. wait until eithor prediction is true or timeout
      finish_cond.wait(locker, std::chrono::seconds(1),
              []{ return is_finish; }); 
  }
   
  // thread 2
  {
      is_finish = true;
   
      // 1. notify one of the waiter
      finish_cond.notify_one();
   
      // 2. notify all the waiter
      finish_cond.notify_all();
  }

  
  

  上面的例子，基本覆盖了C++0x提供的条件变量的主要用法。下面我们来一一分析一下，帮助大家更好的理解：

  • （1）关于wait，有三种基本的用法：第1种是在指定的条件上循环等待，直到条件为真notify时才会继续执行后面的逻辑；第2种用法语义上和第1种是一样的，但是不是用户做显式的loop等待，用户传入一个需要满足的条件的closure, wait一直等到这个条件为真被notify时才会返回继续执行下面的逻辑，可以理解为这时候，在wait内部有一个loop；第3 种用法，加了一个超时的语义，wait一直等到条件为真或者超时，被notify时才会返回继续执行下面的逻辑。
  • （2）关于notify, 有两种：第1种是notify_one, 只唤醒一个在wait的线程; 第2种是notify_all，唤醒所有在wait的线程，相当于一个broadcast的语义。

      以上即是今天的主要内容，希望对正在学习C++0x的朋友有所帮助，荣幸之至！
  原创文章,转载请注明出处： 小武哥的博客
  本文固定链接： http://www.wuzesheng.com/?p=2077