Boost是为C++语言标准库提供扩展的一些C++程序库的总称。Boost库是一个可移植、提供源代码的C++库，作为标准库的后备，是C++标准化进程的开发引擎之一，是为C++语言标准库提供扩展的一些C++程序库的总称。

Boost库由C++标准委员会库工作组成员发起，其中有些内容有望成为下一代C++标准库内容。在C++社区中影响甚大，是不折不扣的“准”标准库。

Boost由于其对跨平台的强调，对标准C++的强调，与编写平台无关。但Boost中也有很多是实验性质的东西，在实际的开发中使用需要谨慎。

1 例子

多线程访问同一资源时，为了保证数据的一致性，必要时需要加锁。

1.1 直接操作 mutex，即直接调用 mutex 的 lock / unlock 函数。

#include <iostream>
#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
boost::mutex mutex;
int count = 0;
void Counter() {
  mutex.lock();
  int i = ++count;
  std::cout << "count == " << i << std::endl;
  // 前面代码如有异常，unlock 就调不到了。
  mutex.unlock();
}
int main() {
  boost::thread_group threads;
  for (int i = 0; i < 4; ++i) {
    threads.create_thread(&Counter);
  }
  threads.join_all();
  return 0;
}

1.2 使用 lock_guard 自动加锁、解锁。原理是 RAII，和智能指针类似。

#include <iostream>
#include <boost/thread/lock_guard.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
boost::mutex mutex;
int count = 0;
void Counter() {
  // lock_guard 在构造函数里加锁，在析构函数里解锁。
  boost::lock_guard<boost::mutex> lock(mutex);
  int i = ++count;
  std::cout << "count == " << i << std::endl;
}
int main() {
  boost::thread_group threads;
  for (int i = 0; i < 4; ++i) {
    threads.create_thread(&Counter);
  }
  threads.join_all();
  return 0;
}

1.3 使用 unique_lock 自动加锁、解锁。

unique_lock 与 lock_guard 原理相同，但是提供了更多功能（比如可以结合条件变量使用）。

注意：mutex::scoped_lock 其实就是 unique_lock 的 typedef。

#include <iostream>
#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
boost::mutex mutex;
int count = 0;
void Counter() {
  boost::unique_lock<boost::mutex> lock(mutex);
  int i = ++count;
  std::cout << "count == " << i << std::endl;
}
int main() {
  boost::thread_group threads;
  for (int i = 0; i < 4; ++i) {
    threads.create_thread(&Counter);
  }
  threads.join_all();
  return 0;
}

2 unique_lock和lock_guard的区别

简单的说，unique_lock相对于lock_guard,会有更多特性。

unique_lock和lock_guard都遵循RAII。

unique_lock和lock_guard最大的不同是unique_lock不需要始终拥有关联的mutex，而lock_guard始终拥有mutex。这意味着unique_lock需要利用owns_lock()判断是否拥有mutex。另外，如果要结合使用条件变量，应该使用unique_lock。

Lock doesn't have to taken right at the construction, you can pass the flag std::defer_lock during its construction to keep the mutex unlocked during construction.

We can unlock it before the function ends and don't have to necessarily wait for destructor to release it, which can be handy.

You can pass the ownership of the lock from a function, it is movable and not copyable.

It can be used with conditional variables since that requires mutex to be locked, condition checked and unlocked while waiting for a condition.

参考[StackOverflow]:https://stackoverflow.com/questions/6731027/boostunique-lock-vs-boostlock-guard

转自cnblogs.com/dengchj/p/9198121.html

本文链接:https://www.it72.com/12701.htm