并行运行的两个线程分别读和写同一个数据。
std:;vector<int> vec;
if (!vec.empty())
{
std::cout << v.front() << std::endl;
}
上述代码在单线程中的运行可以满足其语义。然而，在多线程情况中，我们不能保证在 if 判断之后和 front 调用之前，该 vector 没有被改变。
如果两个线程分别执行下面两段代码：
long long x = 0;
x = -1;
std::cout << x;
打印的值是不确定的，有可能是-1，有可能是0，有可能是在某次写入只写入一半时的数据。C++标准并不保证对于基本类型的写入是原子操作。
考虑下面三段代码（第一段为全局变量声明，剩下两段分别为两个线程中运行的代码）：
long data;
bool readyFlag = false;
data = 42;
readyFlag = true;
while (!readyFlag)
{
;
}
foo(data);
如果代码按照我们书写的顺序执行，我们确实可以认为在调用 foo() 函数时，其参数为42。然而，实际情况却是编译器或硬件可能会调整语句的执行顺序。因为C++标准只要求编译的代码在单一线程内的可观测行为正确。
C++标准库所提供的办法包括：
在C++11之前，语言本身和标准库都不支持并发，虽然编译器实现可以对此提供某些支持。C++11中，不论内核语言或标准都加强支持并发编程。
对于语言本身：
标准库提供以下保证：
Mutex 全名 mutual exclusion，是个 object，用来协助采取独占地排他方式控制”对资源的并发访问“。这里所谓“资源”可能是个 object，或多个 object 的组合。为了获得独占式的资源访问能力，相应的线程锁定 mutex，这样可以防止其它线程也锁定 mutex。
下面的代码展示了在两个线程中，互斥体的使用：
// global
int val;
std::mutex valMutex;
// thread1
valMutex.lock();
if (val >= 0) {
f(val);
} else {
f(-val);
}
valMutex.unlock();
// thread2
valMutex.lock();
val++;
valMutex.unlock();
这里需要注意，mutex 的构造并不和某个对象绑定。其和一个或一组对象的绑定是语义上的，体现在代码中。
但是，这种使用较为麻烦。有时我们会在一个线程的多处进行退出；有时线程中会抛出异常。如果在任何一个地方我们忘记解锁，就会造成死锁的结果。因此，我们需要遵守 RAII 守则（可以参考 《Effictive C++》学习笔记 — 资源管理）。在标准库中，我们可以使用 lock_guard 实现这样的功能：
#include <iostream>
#include <mutex>
using namespace std;
int val;
mutex valMutex;
int main()
{
lock_guard lg(valMutex);
if (val > 10)
{
return 1;
}
else if (val < 0)
{
return -1;
}
else
{
return 0;
}
}
如果不使用这种方式，我们可能需要使用 goto 这种非结构化编程的方式。
有时候，递归锁定是必要的。典型例子是数据库接口，它在每个公有函数内放一个 mutex 并取得 lock，以防止数据竞争带来的对象状态异常。例如：
class DBAcess
{
private:
mutex dbMutex;
...
public:
void createTable(...)
{
lock_guard lg(dbMutex);
...
}
void insertData(...)
{
lock_guard lg(dbMutex);
...
}
};
但是如果有一个接口想要调用另外一个接口，将会造成死锁：
void createTableAndInsertTable(...)
{
lock_guard lg(dbMutex);
...
createTable(...);
}
在这种情况下，我们可以使用 recursive lock。这种 mutex 允许我们多次 lock，只要 unlock 和 lock 是一一对应的。
有时候程序想要获得一个 lock 但如果不可能成功的话，它不想永远阻塞。针对这种情况，我们可以使用 try_lock()，它试图取得一个 lock，成功就返回 true，否则就返回 false。
为了仍然能够使用 lock_guard （使当前作用域的任何出口都会自动解锁），我们可以传一个额外的实参 adopt_lock 给其构造函数，其作用在于不再构造时加锁：
while (valMutex.try_lock() == false) {
doSomething();
}
lock_guard lg(valMutex, adopt_lock);
为了等待特定长度的时间，我们可以选用 timed_mutex：
timed_mutex valMutex;
if (valMutex.try_lock_for(chrono::seconds(1)))
{
lock_guard lg(valMutex, adopt_lock);
}
不同的锁可能会控制着不同的资源。但是，在某些事务中，可能我们需要按某种固定的顺序访问这些资源并在它们之间进行数据传递。因此，我们需要同时加多个锁。C++标准库中提供了全局 lock 函数来实现这种功能：
mutex mutex1;
mutex mutex2;
mutex mutex3;
lock(mutex1, mutex2, mutex3);
lock_guard lg1(mutex1, adopt_lock);
lock_guard lg2(mutex2, adopt_lock);
lock_guard lg3(mutex3, adopt_lock);
类似地，我们可以使用全局 try_lock() 函数对多个互斥体尝试加锁。该函数在所有加锁都成功的情况下会返回-1，否则返回加锁失败的 index，该次序与参数次序一致。
除了使用 lock_guard，C++标准库还提供了 unique_lock。该类除了支持 RAII，还支持我们指定何时以及如何解锁。因此，一个 unique_lock 对象可能拥有一个锁住的互斥体，也可能没有。该类提供的方法如下：
其功能与 unique_ptr 非常类似，允许在不同的对象之间交换所管理的 mutex 对象及状态。书中关于 release() 的说法有些问题。该函数仅仅用于解除 unique_lock 和其管理的 mutex 的关联，而不会释放 mutex。
shared_mutex 是C++17中提出的一种互斥体。这种互斥体类似读写锁，提供了两种不同级别的访问：使用 lock() 会阻止所有线程其他线程锁定互斥体；使用 shared_lock() 可以在多线程中同时访问数据：
#include <iostream>
#include <future>
#include <shared_mutex>
#include <chrono>
#include <memory>
using namespace std;
shared_mutex mutex1;
int testData = 1;
void lockData()
{
unique_lock<shared_mutex> mutex(mutex1);
for (int i = 0; i < 5; ++i)
{
this_thread::sleep_for(chrono::milliseconds(100));
cout << "lockData -- " << testData << endl;
testData++;
}
}
void sharedLockReadData()
{
shared_lock<shared_mutex> mutex(mutex1);
for (int i = 0; i < 5; ++i)
{
this_thread::sleep_for(chrono::seconds(1));
cout << "sharedLockReadData -- " << this_thread::get_id() << " --" << testData << endl;
}
}
int main()
{
auto result1 = async(lockData);
auto result2 = async(sharedLockReadData);
auto result3 = async(sharedLockReadData);
result1.get();
result2.get();
result3.get();
}
有时候某些数据在第一次被初始化后，其他线程直接使用该数据即可。以单例的懒汉式为例。如果我们想要正确的在多线程情况下实现懒汉式，需要在判断静态对象是否为空之前增加锁。在C++中，我们可以使用 once_flag 和 call_once 实现此功能：
#include <iostream>
#include <future>
#include <shared_mutex>
#include <chrono>
#include <memory>
using namespace std;
class Data
{
public:
Data()
{
this_thread::sleep_for(chrono::milliseconds(100));
cout << "initData" << endl;
}
static Data* getData()
{
/*if (data == nullptr)
{
data = new Data;
}*/
call_once(initFlag, []() {data = new Data; });
return data;
}
private:
static Data* data;
static once_flag initFlag;
};
Data* Data::data = nullptr;
once_flag Data::initFlag;
void getData()
{
Data::getData();
}
int main()
{
auto result1 = async(getData);
auto result2 = async(getData);
result1.get();
result2.get();
}
