在 《C++11 并发指南三(std::mutex 详解)》一文中我们主要介绍了 C++11 标准中的互斥量(Mutex)，并简单介绍了一下两种锁类型。本节将详细介绍一下 C++11 标准的锁类型。

C++11 标准为我们提供了两种基本的锁类型，分别如下：

  • std::lock_guard，与 Mutex RAII 相关，方便线程对互斥量上锁。
  • std::unique_lock，与 Mutex RAII 相关，方便线程对互斥量上锁，但提供了更好的上锁和解锁控制。

另外还提供了几个与锁类型相关的 Tag 类，分别如下:

  • std::adopt_lock_t，一个空的标记类，定义如下：
struct adopt_lock_t {};

该类型的常量对象adopt_lock（adopt_lock 是一个常量对象，定义如下：

constexpr adopt_lock_t adopt_lock {};，// constexpr 是 C++11 中的新关键字）

通常作为参数传入给 unique_lock 或 lock_guard 的构造函数。

  • std::defer_lock_t，一个空的标记类，定义如下： 
struct defer_lock_t {};

该类型的常量对象 defer_lock（defer_lock 是一个常量对象，定义如下：

constexpr defer_lock_t defer_lock {};，// constexpr 是 C++11 中的新关键字）

通常作为参数传入给 unique_lock 或 lock_guard 的构造函数。

  • std::try_to_lock_t，一个空的标记类，定义如下：
struct try_to_lock_t {};

该类型的常量对象 try_to_lock（try_to_lock 是一个常量对象，定义如下：

constexpr try_to_lock_t try_to_lock {};，// constexpr 是 C++11 中的新关键字）

通常作为参数传入给 unique_lock 或 lock_guard 的构造函数。后面我们会详细介绍以上三种 Tag 类型在配合 lock_gurad 与 unique_lock 使用时的区别。

std::lock_guard 介绍

std::lock_gurad 是 C++11 中定义的模板类。定义如下：

template <class Mutex> class lock_guard;

lock_guard 对象通常用于管理某个锁(Lock)对象，因此与 Mutex RAII 相关，方便线程对互斥量上锁，即在某个 lock_guard 对象的声明周期内，它所管理的锁对象会一直保持上锁状态；而 lock_guard 的生命周期结束之后，它所管理的锁对象会被解锁(注：类似 shared_ptr 等智能指针管理动态分配的内存资源 )。

模板参数 Mutex 代表互斥量类型，例如 std::mutex 类型，它应该是一个基本的 BasicLockable 类型，标准库中定义几种基本的 BasicLockable 类型，分别 std::mutex, std::recursive_mutex, std::timed_mutex，std::recursive_timed_mutex (以上四种类型均已在上一篇博客中介绍)以及 std::unique_lock(本文后续会介绍 std::unique_lock)。(注：BasicLockable 类型的对象只需满足两种操作，lock 和 unlock，另外还有 Lockable 类型，在 BasicLockable 类型的基础上新增了 try_lock 操作，因此一个满足 Lockable 的对象应支持三种操作：lock，unlock 和 try_lock；最后还有一种 TimedLockable 对象，在 Lockable 类型的基础上又新增了 try_lock_for 和 try_lock_until 两种操作，因此一个满足 TimedLockable 的对象应支持五种操作：lock, unlock, try_lock, try_lock_for, try_lock_until)。

在 lock_guard 对象构造时，传入的 Mutex 对象(即它所管理的 Mutex 对象)会被当前线程锁住。在lock_guard 对象被析构时，它所管理的 Mutex 对象会自动解锁，由于不需要程序员手动调用 lock 和 unlock 对 Mutex 进行上锁和解锁操作，因此这也是最简单安全的上锁和解锁方式，尤其是在程序抛出异常后先前已被上锁的 Mutex 对象可以正确进行解锁操作，极大地简化了程序员编写与 Mutex 相关的异常处理代码。

值得注意的是，lock_guard 对象并不负责管理 Mutex 对象的生命周期，lock_guard 对象只是简化了 Mutex 对象的上锁和解锁操作，方便线程对互斥量上锁，即在某个 lock_guard 对象的声明周期内，它所管理的锁对象会一直保持上锁状态；而 lock_guard 的生命周期结束之后，它所管理的锁对象会被解锁。

std::lock_guard 构造函数

lock_guard 构造函数如下表所示：

locking (1) 
explicit lock_guard (mutex_type& m);
adopting (2) 
lock_guard (mutex_type& m, adopt_lock_t tag);
copy [deleted](3) 
lock_guard (const lock_guard&) = delete;
  1. locking 初始化

    • lock_guard 对象管理 Mutex 对象 m，并在构造时对 m 进行上锁（调用 m.lock()）。
  2. adopting初始化
    • lock_guard 对象管理 Mutex 对象 m，与 locking 初始化(1) 不同的是， Mutex 对象 m 已被当前线程锁住。
  3. 拷贝构造
    • lock_guard 对象的拷贝构造和移动构造(move construction)均被禁用，因此 lock_guard 对象不可被拷贝构造或移动构造。

我们来看一个简单的例子(参考)：

#include <iostream>       // std::cout

#include <thread>         // std::thread

#include <mutex>          // std::mutex, std::lock_guard, std::adopt_lock

std::mutex mtx;           // mutex for critical section

void print_thread_id (int id) {

  mtx.lock();

  std::lock_guard<std::mutex> lck(mtx, std::adopt_lock);

  std::cout << "thread #" << id << '\n';

}

int main ()

{

  std::thread threads[];

  // spawn 10 threads:

  for (int i=; i<; ++i)

    threads[i] = std::thread(print_thread_id,i+);

  for (auto& th : threads) th.join();

  return ;

}

在 print_thread_id 中，我们首先对 mtx 进行上锁操作(mtx.lock();)，然后用 mtx 对象构造一个 lock_guard 对象(std::lock_guard<std::mutex> lck(mtx, std::adopt_lock);)，注意此时 Tag 参数为 std::adopt_lock，表明当前线程已经获得了锁，此后 mtx 对象的解锁操作交由 lock_guard 对象 lck 来管理，在 lck 的生命周期结束之后，mtx 对象会自动解锁。

lock_guard 最大的特点就是安全易于使用，请看下面例子(参考)，在异常抛出的时候通过 lock_guard 对象管理的 Mutex 可以得到正确地解锁。

#include <iostream>       // std::cout

#include <thread>         // std::thread

#include <mutex>          // std::mutex, std::lock_guard

#include <stdexcept>      // std::logic_error

std::mutex mtx;

void print_even (int x) {

  if (x%==) std::cout << x << " is even\n";

  else throw (std::logic_error("not even"));

}

void print_thread_id (int id) {

  try {

    // using a local lock_guard to lock mtx guarantees unlocking on destruction / exception:

    std::lock_guard<std::mutex> lck (mtx);

    print_even(id);

  }

  catch (std::logic_error&) {

    std::cout << "[exception caught]\n";

  }

}

int main ()

{

  std::thread threads[];

  // spawn 10 threads:

  for (int i=; i<; ++i)

    threads[i] = std::thread(print_thread_id,i+);

  for (auto& th : threads) th.join();

  return ;

}

std::unique_lock 介绍

但是 lock_guard 最大的缺点也是简单，没有给程序员提供足够的灵活度，因此，C++11 标准中定义了另外一个与 Mutex RAII 相关类 unique_lock，该类与 lock_guard 类相似，也很方便线程对互斥量上锁，但它提供了更好的上锁和解锁控制。

顾名思义，unique_lock 对象以独占所有权的方式（ unique owership）管理 mutex 对象的上锁和解锁操作，所谓独占所有权，就是没有其他的 unique_lock 对象同时拥有某个 mutex 对象的所有权。

在构造(或移动(move)赋值)时，unique_lock 对象需要传递一个 Mutex 对象作为它的参数，新创建的 unique_lock 对象负责传入的 Mutex 对象的上锁和解锁操作。

std::unique_lock 对象也能保证在其自身析构时它所管理的 Mutex 对象能够被正确地解锁（即使没有显式地调用 unlock 函数）。因此，和 lock_guard 一样，这也是一种简单而又安全的上锁和解锁方式，尤其是在程序抛出异常后先前已被上锁的 Mutex 对象可以正确进行解锁操作，极大地简化了程序员编写与 Mutex 相关的异常处理代码。

值得注意的是，unique_lock 对象同样也不负责管理 Mutex 对象的生命周期，unique_lock 对象只是简化了 Mutex 对象的上锁和解锁操作，方便线程对互斥量上锁，即在某个 unique_lock 对象的声明周期内，它所管理的锁对象会一直保持上锁状态；而 unique_lock 的生命周期结束之后，它所管理的锁对象会被解锁，这一点和 lock_guard 类似，但 unique_lock 给程序员提供了更多的自由，我会在下面的内容中给大家介绍 unique_lock 的用法。

另外，与 lock_guard 一样，模板参数 Mutex 代表互斥量类型，例如 std::mutex 类型，它应该是一个基本的 BasicLockable 类型，标准库中定义几种基本的 BasicLockable 类型，分别 std::mutex, std::recursive_mutex, std::timed_mutex，std::recursive_timed_mutex (以上四种类型均已在上一篇博客中介绍)以及 std::unique_lock(本文后续会介绍 std::unique_lock)。(注：BasicLockable 类型的对象只需满足两种操作，lock 和 unlock，另外还有 Lockable 类型，在 BasicLockable 类型的基础上新增了 try_lock 操作，因此一个满足 Lockable 的对象应支持三种操作：lock，unlock 和 try_lock；最后还有一种 TimedLockable 对象，在 Lockable 类型的基础上又新增了 try_lock_for 和 try_lock_until 两种操作，因此一个满足 TimedLockable 的对象应支持五种操作：lock, unlock, try_lock, try_lock_for, try_lock_until)。

std::unique_lock 构造函数

std::unique_lock 的构造函数的数目相对来说比 std::lock_guard 多，其中一方面也是因为 std::unique_lock 更加灵活，从而在构造 std::unique_lock 对象时可以接受额外的参数。总地来说，std::unique_lock 构造函数如下：

default (1) 
unique_lock() noexcept;
locking (2) 
explicit unique_lock(mutex_type& m);
try-locking (3) 
unique_lock(mutex_type& m, try_to_lock_t tag);
deferred (4) 
unique_lock(mutex_type& m, defer_lock_t tag) noexcept;
adopting (5) 
unique_lock(mutex_type& m, adopt_lock_t tag);
locking for (6) 
template <class Rep, class Period>

unique_lock(mutex_type& m, const chrono::duration<Rep,Period>& rel_time);
locking until (7) 
template <class Clock, class Duration>

unique_lock(mutex_type& m, const chrono::time_point<Clock,Duration>& abs_time);
copy [deleted] (8) 
unique_lock(const unique_lock&) = delete;
move (9) 
unique_lock(unique_lock&& x);

下面我们来分别介绍以上各个构造函数：

(1) 默认构造函数
新创建的 unique_lock 对象不管理任何 Mutex 对象。
(2) locking 初始化
新创建的 unique_lock 对象管理 Mutex 对象 m，并尝试调用 m.lock() 对 Mutex 对象进行上锁，如果此时另外某个 unique_lock 对象已经管理了该 Mutex 对象 m，则当前线程将会被阻塞。
(3) try-locking 初始化
新创建的 unique_lock 对象管理 Mutex 对象 m，并尝试调用 m.try_lock() 对 Mutex 对象进行上锁，但如果上锁不成功，并不会阻塞当前线程。
(4) deferred 初始化
新创建的 unique_lock 对象管理 Mutex 对象 m，但是在初始化的时候并不锁住 Mutex 对象。 m 应该是一个没有当前线程锁住的 Mutex 对象。
(5) adopting 初始化
新创建的 unique_lock 对象管理 Mutex 对象 m， m 应该是一个已经被当前线程锁住的 Mutex 对象。(并且当前新创建的 unique_lock 对象拥有对锁(Lock)的所有权)。
(6) locking 一段时间(duration)
新创建的 unique_lock 对象管理 Mutex 对象 m，并试图通过调用 m.try_lock_for(rel_time) 来锁住 Mutex 对象一段时间(rel_time)。
(7) locking 直到某个时间点(time point)
新创建的 unique_lock 对象管理 Mutex 对象m，并试图通过调用 m.try_lock_until(abs_time) 来在某个时间点(abs_time)之前锁住 Mutex 对象。
(8) 拷贝构造 [被禁用]
unique_lock 对象不能被拷贝构造。
(9) 移动(move)构造
新创建的 unique_lock 对象获得了由 x 所管理的 Mutex 对象的所有权(包括当前 Mutex 的状态)。调用 move 构造之后， x 对象如同通过默认构造函数所创建的，就不再管理任何 Mutex 对象了。

综上所述，由 (2) 和 (5) 创建的 unique_lock 对象通常拥有 Mutex 对象的锁。而通过 (1) 和 (4) 创建的则不会拥有锁。通过 (3)，(6) 和 (7) 创建的 unique_lock 对象，则在 lock 成功时获得锁。

关于unique_lock 的构造函数，请看下面例子(参考)：

#include <iostream>       // std::cout

#include <thread>         // std::thread

#include <mutex>          // std::mutex, std::lock, std::unique_lock

                          // std::adopt_lock, std::defer_lock

std::mutex foo,bar;

void task_a () {

  std::lock (foo,bar);         // simultaneous lock (prevents deadlock)

  std::unique_lock<std::mutex> lck1 (foo,std::adopt_lock);

  std::unique_lock<std::mutex> lck2 (bar,std::adopt_lock);

  std::cout << "task a\n";

  // (unlocked automatically on destruction of lck1 and lck2)

}

void task_b () {

  // foo.lock(); bar.lock(); // replaced by:

  std::unique_lock<std::mutex> lck1, lck2;

  lck1 = std::unique_lock<std::mutex>(bar,std::defer_lock);

  lck2 = std::unique_lock<std::mutex>(foo,std::defer_lock);

  std::lock (lck1,lck2);       // simultaneous lock (prevents deadlock)

  std::cout << "task b\n";

  // (unlocked automatically on destruction of lck1 and lck2)

}

int main ()

{

  std::thread th1 (task_a);

  std::thread th2 (task_b);

  th1.join();

  th2.join();

  return ;

}

std::unique_lock 移动(move assign)赋值操作

std::unique_lock 支持移动赋值(move assignment)，但是普通的赋值被禁用了，

move (1) 
unique_lock& operator= (unique_lock&& x) noexcept;
copy [deleted] (2) 
unique_lock& operator= (const unique_lock&) = delete;

移动赋值(move assignment)之后，由 x 所管理的 Mutex 对象及其状态将会被新的 std::unique_lock 对象取代。

如果被赋值的对象之前已经获得了它所管理的 Mutex 对象的锁，则在移动赋值(move assignment)之前会调用 unlock 函数释放它所占有的锁。

调用移动赋值(move assignment)之后， x 对象如同通过默认构造函数所创建的，也就不再管理任何 Mutex 对象了。请看下面例子(参考)：

#include <iostream>       // std::cout

#include <thread>         // std::thread

#include <mutex>          // std::mutex, std::unique_lock

std::mutex mtx;           // mutex for critical section

void print_fifty (char c) {

  std::unique_lock<std::mutex> lck;         // default-constructed

  lck = std::unique_lock<std::mutex>(mtx);  // move-assigned

  for (int i=; i<; ++i) { std::cout << c; }

  std::cout << '\n';

}

int main ()

{

  std::thread th1 (print_fifty,'*');

  std::thread th2 (print_fifty,'$');

  th1.join();

  th2.join();

  return ;

}

std::unique_lock 主要成员函数

本节我们来看看 std::unique_lock 的主要成员函数。由于 std::unique_lock 比 std::lock_guard 操作灵活，因此它提供了更多成员函数。具体分类如下：

  1. 上锁/解锁操作：lock，try_lock，try_lock_for，try_lock_until 和 unlock
  2. 修改操作：移动赋值(move assignment)(前面已经介绍过了)，交换(swap)（与另一个 std::unique_lock 对象交换它们所管理的 Mutex 对象的所有权），释放(release)（返回指向它所管理的 Mutex 对象的指针，并释放所有权）
  3. 获取属性操作：owns_lock（返回当前 std::unique_lock 对象是否获得了锁）、operator bool()（与 owns_lock 功能相同，返回当前 std::unique_lock 对象是否获得了锁）、mutex（返回当前 std::unique_lock 对象所管理的 Mutex 对象的指针）。

std::unique_lock::lock请看下面例子(参考)：

上锁操作，调用它所管理的 Mutex 对象的 lock 函数。如果在调用  Mutex 对象的 lock 函数时该 Mutex 对象已被另一线程锁住，则当前线程会被阻塞，直到它获得了锁。

该函数返回时，当前的 unique_lock 对象便拥有了它所管理的 Mutex 对象的锁。如果上锁操作失败，则抛出 system_error 异常。

// unique_lock::lock/unlock

#include <iostream>       // std::cout

#include <thread>         // std::thread

#include <mutex>          // std::mutex, std::unique_lock, std::defer_lock

std::mutex mtx;           // mutex for critical section

void print_thread_id (int id) {

  std::unique_lock<std::mutex> lck (mtx,std::defer_lock);

  // critical section (exclusive access to std::cout signaled by locking lck):

  lck.lock();

  std::cout << "thread #" << id << '\n';

  lck.unlock();

}

int main ()

{

  std::thread threads[];

  // spawn 10 threads:

  for (int i=; i<; ++i)

    threads[i] = std::thread(print_thread_id,i+);

  for (auto& th : threads) th.join();

  return ;

}

std::unique_lock::try_lock

上锁操作，调用它所管理的 Mutex 对象的 try_lock 函数，如果上锁成功，则返回 true，否则返回 false。

请看下面例子(参考)：

#include <iostream>       // std::cout

#include <vector>         // std::vector

#include <thread>         // std::thread

#include <mutex>          // std::mutex, std::unique_lock, std::defer_lock

std::mutex mtx;           // mutex for critical section

void print_star () {

  std::unique_lock<std::mutex> lck(mtx,std::defer_lock);

  // print '*' if successfully locked, 'x' otherwise:

  if (lck.try_lock())

    std::cout << '*';

  else

    std::cout << 'x';

}

int main ()

{

  std::vector<std::thread> threads;

  for (int i=; i<; ++i)

    threads.emplace_back(print_star);

  for (auto& x: threads) x.join();

  return ;

}

std::unique_lock::try_lock_for

上锁操作，调用它所管理的 Mutex 对象的 try_lock_for 函数，如果上锁成功，则返回 true，否则返回 false。

请看下面例子(参考)：

#include <iostream>       // std::cout

#include <chrono>         // std::chrono::milliseconds

#include <thread>         // std::thread

#include <mutex>          // std::timed_mutex, std::unique_lock, std::defer_lock

std::timed_mutex mtx;

void fireworks () {

  std::unique_lock<std::timed_mutex> lck(mtx,std::defer_lock);

  // waiting to get a lock: each thread prints "-" every 200ms:

  while (!lck.try_lock_for(std::chrono::milliseconds())) {

    std::cout << "-";

  }

  // got a lock! - wait for 1s, then this thread prints "*"

  std::this_thread::sleep_for(std::chrono::milliseconds());

  std::cout << "*\n";

}

int main ()

{

  std::thread threads[];

  // spawn 10 threads:

  for (int i=; i<; ++i)

    threads[i] = std::thread(fireworks);

  for (auto& th : threads) th.join();

  return ;

}

std::unique_lock::try_lock_until

上锁操作，调用它所管理的 Mutex 对象的 try_lock_for 函数，如果上锁成功，则返回 true，否则返回 false。

请看下面例子(参考)：

#include <iostream>       // std::cout

#include <chrono>         // std::chrono::milliseconds

#include <thread>         // std::thread

#include <mutex>          // std::timed_mutex, std::unique_lock, std::defer_lock

std::timed_mutex mtx;

void fireworks () {

  std::unique_lock<std::timed_mutex> lck(mtx,std::defer_lock);

  // waiting to get a lock: each thread prints "-" every 200ms:

  while (!lck.try_lock_for(std::chrono::milliseconds())) {

    std::cout << "-";

  }

  // got a lock! - wait for 1s, then this thread prints "*"

  std::this_thread::sleep_for(std::chrono::milliseconds());

  std::cout << "*\n";

}

int main ()

{

  std::thread threads[];

  // spawn 10 threads:

  for (int i=; i<; ++i)

    threads[i] = std::thread(fireworks);

  for (auto& th : threads) th.join();

  return ;

}

std::unique_lock::unlock

解锁操作，调用它所管理的 Mutex 对象的 unlock 函数。

请看下面例子(参考)：

#include <iostream>       // std::cout

#include <thread>         // std::thread

#include <mutex>          // std::mutex, std::unique_lock, std::defer_lock

std::mutex mtx;           // mutex for critical section

void print_thread_id (int id) {

  std::unique_lock<std::mutex> lck (mtx,std::defer_lock);

  // critical section (exclusive access to std::cout signaled by locking lck):

  lck.lock();

  std::cout << "thread #" << id << '\n';

  lck.unlock();

}

int main ()

{

  std::thread threads[];

  // spawn 10 threads:

  for (int i=; i<; ++i)

    threads[i] = std::thread(print_thread_id,i+);

  for (auto& th : threads) th.join();

  return ;

}

std::unique_lock::release

返回指向它所管理的 Mutex 对象的指针，并释放所有权。

请看下面例子(参考)：

#include <iostream>       // std::cout

#include <vector>         // std::vector

#include <thread>         // std::thread

#include <mutex>          // std::mutex, std::unique_lock

std::mutex mtx;

int count = ;

void print_count_and_unlock (std::mutex* p_mtx) {

  std::cout << "count: " << count << '\n';

  p_mtx->unlock();

}

void task() {

  std::unique_lock<std::mutex> lck(mtx);

  ++count;

  print_count_and_unlock(lck.release());

}

int main ()

{

  std::vector<std::thread> threads;

  for (int i=; i<; ++i)

    threads.emplace_back(task);

  for (auto& x: threads) x.join();

  return ;

}

std::unique_lock::owns_lock

返回当前 std::unique_lock 对象是否获得了锁。

请看下面例子(参考)：

#include <iostream>       // std::cout

#include <vector>         // std::vector

#include <thread>         // std::thread

#include <mutex>          // std::mutex, std::unique_lock, std::try_to_lock

std::mutex mtx;           // mutex for critical section

void print_star () {

  std::unique_lock<std::mutex> lck(mtx,std::try_to_lock);

  // print '*' if successfully locked, 'x' otherwise:

  if (lck.owns_lock())

    std::cout << '*';

  else

    std::cout << 'x';

}

int main ()

{

  std::vector<std::thread> threads;

  for (int i=; i<; ++i)

    threads.emplace_back(print_star);

  for (auto& x: threads) x.join();

  return ;

}

std::unique_lock::operator bool()

与 owns_lock 功能相同，返回当前 std::unique_lock 对象是否获得了锁。

请看下面例子(参考)：

#include <iostream>       // std::cout

#include <vector>         // std::vector

#include <thread>         // std::thread

#include <mutex>          // std::mutex, std::unique_lock, std::try_to_lock

std::mutex mtx;           // mutex for critical section

void print_star () {

  std::unique_lock<std::mutex> lck(mtx,std::try_to_lock);

  // print '*' if successfully locked, 'x' otherwise:

  if (lck)

    std::cout << '*';

  else

    std::cout << 'x';

}

int main ()

{

  std::vector<std::thread> threads;

  for (int i=; i<; ++i)

    threads.emplace_back(print_star);

  for (auto& x: threads) x.join();

  return ;

}

std::unique_lock::mutex

返回当前 std::unique_lock 对象所管理的 Mutex 对象的指针。

请看下面例子(参考)：

#include <iostream>       // std::cout

#include <thread>         // std::thread

#include <mutex>          // std::mutex, std::unique_lock, std::defer_lock

class MyMutex : public std::mutex {

  int _id;

public:

  MyMutex (int id) : _id(id) {}

  int id() {return _id;}

};

MyMutex mtx ();

void print_ids (int id) {

  std::unique_lock<MyMutex> lck (mtx);

  std::cout << "thread #" << id << " locked mutex " << lck.mutex()->id() << '\n';

}

int main ()

{

  std::thread threads[];

  // spawn 10 threads:

  for (int i=; i<; ++i)

    threads[i] = std::thread(print_ids,i+);

  for (auto& th : threads) th.join();

  return ;

}

好了，本文先介绍到这里，我们基本上介绍完了 C++11 多线程编程中两种最基本的锁类型，后面我会继续更新有关 C++11 并发编程的博客，希望感兴趣的同学继续关注 ;-)

C++11 并发指南三(Lock 详解)的更多相关文章

  1. C++11 并发指南三(Lock 详解)（转载）

    multithreading 多线程 C++11 C++11多线程基本使用 C++11 并发指南三(Lock 详解) 在 <C++11 并发指南三(std::mutex 详解)>一文中我们 ...

  2. C++11 并发指南四(<future> 详解三 std::future & std::shared_future)

    上一讲<C++11 并发指南四(<future> 详解二 std::packaged_task 介绍)>主要介绍了 <future> 头文件中的 std::pack ...

  3. C++11 并发指南四(<future> 详解三 std::future & std::shared_future)（转）

    上一讲<C++11 并发指南四(<future> 详解二 std::packaged_task 介绍)>主要介绍了 <future> 头文件中的 std::pack ...

  4. C++11 并发指南四(<future> 详解二 std::packaged_task 介绍)

    上一讲<C++11 并发指南四(<future> 详解一 std::promise 介绍)>主要介绍了 <future> 头文件中的 std::promise 类, ...

  5. C++11 并发指南四(<future> 详解一 std::promise 介绍)

    前面两讲<C++11 并发指南二(std::thread 详解)>,<C++11 并发指南三(std::mutex 详解)>分别介绍了 std::thread 和 std::m ...

  6. C++11 并发指南四(<future> 详解一 std::promise 介绍)（转）

    前面两讲<C++11 并发指南二(std::thread 详解)>,<C++11 并发指南三(std::mutex 详解)>分别介绍了 std::thread 和 std::m ...

  7. C++11 并发指南------std::thread 详解

    参考: https://github.com/forhappy/Cplusplus-Concurrency-In-Practice/blob/master/zh/chapter3-Thread/Int ...

  8. 转 C++11 并发指南std::condition_variable详解

    之前看过,但是一直没有怎么用就忘了,转一篇别人的文字记录下来 本文将介绍 C++11 标准中 <condition_variable> 头文件里面的类和相关函数. <conditio ...

  9. 【C/C++开发】C++11 并发指南三(std::mutex 详解)

    本系列文章主要介绍 C++11 并发编程,计划分为 9 章介绍 C++11 的并发和多线程编程,分别如下: C++11 并发指南一(C++11 多线程初探)(本章计划 1-2 篇,已完成 1 篇) C ...

随机推荐

  1. oracle 客户端重新安装遇到的问题

    前一阵,因为把ORACLE客户端的密码忘记了,在网上也找了好多方法,试着不重新安装找回密码,可是都行不通,没有办法重新装.安装时遇到一些问题,因为我是WIN7,64位系统,安装的oracle11g64 ...

  2. LC.exe已退出，代码为-1错误

    因为证书的原因,把项目中“properties”目录下的“license.licx”文件删除,再编译就成功了.如图:

  3. swift使用swifthttp

    1.https://github.com/daltoniam/SwiftHTTP下载 2.将项目中的Source文件夹中的所有.swift拖到项目中 3.不用import 4.直接用HTTP.GET或 ...

  4. The certificate used to sign “AppName” has either expired or has been revoked. An updated certificate is required to sign and install the application解决

    问题 The certificate used to sign "AppName" has either expired or has been revoked. An updat ...

  5. Tornado sqlalchemy

    上篇文章提到了,最近在用 Python 做一个网站.除了 Tornado ,主要还用到了 SQLAlchemy.这篇就是介绍我在使用 SQLAlchemy 的过程中,学到的一些知识. 首先说下,由于最 ...

  6. Java 技术体系图

    Java 程序员 高级特性 反射.泛型.注释符.自动装箱和拆箱.枚举类.可变 参数.可变返回类型.增强循环.静态导入 核心编程 IO.多线程.实体类. 集合类.正则表达式. XML 和属性文件 图形编 ...

  7. CentOS7安装mysql5.7.11

    开始安装 yum update yum install wget wget http://repo.mysql.com/mysql57-community-release-el7-7.noarch.r ...

  8. expdp报错ora 39126

    11.2.0.2,expdp报错: ORA-39126: Worker unexpected fatal error in KUPW$WORKER.GET_TABLE_DATA_OBJECTS []O ...

  9. ue4 SNew补遗

    上一篇分析了SNew背后的实现,但是有一个关键问题遗漏了,那就是: #define SNew( WidgetType, ... ) \ MakeTDecl<WidgetType>( #Wi ...

  10. ReferenceQueue的使用

    转:http://www.iflym.com/index.php/java-programe/201407140001.html 1 何为ReferenceQueue 在java的引用体系中,存在着强 ...