load [%counter], rax; // 线程1从counter读取0到寄存器rax
add rax, 1; // 线程1对寄存器rax进行加1
load [%counter], rbx; // 线程2从counter读取0到寄存器rbx
store rax [%counter]; // 线程1把1写入counter的主存地址
add rbx, 1; // 线程2对寄存器rbx进行加1
store rbx, [%counter]; // 线程2把1写入counter的主存地址

为了防止例1中的数据竞跑现象，我们可以使用锁来保证每个线程对counter++操作的独占访问（即保证该操作是原子的）。在例3的程序中，我们使用mutex锁将counter++操作放入临界区中，这样同一时刻只有获取锁的线程能访问该临界区，保证了counter++的原子性：即只有在线程1执行完counter++的三条指令之后线程2才能执行counter++操作，保证了counter的最终值必定为2。

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <algorithm>int counter = 0;
std::mutex mt; void thread_task()
{
//  mt.lock();for(int i=0; i<1000; ++i)counter++;
//  mt.unlock();
}int main()
{std::vector<std::thread> workers;for(int i=0; i<5; ++i){auto t = std::thread(thread_task);workers.push_back(std::move(t));}   std::for_each(workers.begin(), workers.end(), std::mem_fn(&std::thread::join));std::cout<<counter<<std::endl;return 0;
}

// 线程 1
void func1()
{                       LOCK(&mutex_a);                      LOCK(&mutex_b);//线程1停滞在此         counter++;                       UNLOCK(&mutex_b);                     UNLOCK(&mutex_a);
}                       // 线程 2
void func2()
{LOCK(&mutex_b);LOCK(&mutex_a);//线程2停滞在此counter++;UNLOCK(&mutex_a);UNLOCK(&mutex_b);
}

例4中的死锁其实是最简单的情形，在实际的程序中，死锁往往发生在复杂的函数调用过程中。在下面这个例子中，线程1在func1()中获取了mutex_a锁，之后调用func_call1()并在其函数体中尝试获取mutex_b锁；与此同时线程2在func2()中获取了mutex_b锁之后再在func_call2()中尝试获取mutex_a锁从而造成死锁。可以想象，随着程序复杂度的增加，想要正确的检测出死锁会变得越来越困难。
例5：

// 线程 1
void func1()
{
LOCK(&mutex_a);
...
func_call1();
UNLOCK(&mutex_a);
}                       func_call1()
{                       LOCK(&mutex_b);               ...                       UNLOCK(&mutex_b);                 ...
}                       // 线程 2
void func2()
{LOCK(&mutex_b);...func_call2()UNLOCK(&mutex_b);
}func_call2()
{LOCK(&mutex_a);...UNLOCK(&mutex_b);...
}

其实避免死锁的方法非常简单，其基本原则就是保证各个线程加锁操作的执行顺序是全局一致的。例如，如果上例中的线程1和线程2都是先对mutex_a加锁再对mutex_b进行加锁就不会产生死锁了。在实际的软件开发中，除了严格遵守相同加锁顺序的原则防止死锁之外，我们还可以使用RAII（Resource Acquisition Is Initialization，即“资源获取即初始化”）的手段来封装加锁解锁操作，从而帮助减少死锁的发生[1]。

#include <iostream>
#include <unistd.h>
#include <thread>
#include <mutex>
#include <vector>
#include <algorithm>int counter = 0;
std::mutex mt_1;
std::mutex mt_2;void thread_task1()
{mt_1.lock();sleep(1);    //review the deadlockmt_2.lock();counter++;mt_2.unlock();mt_1.unlock();
}void thread_task2()
{mt_2.lock();sleep(1);mt_1.lock();counter++;mt_1.unlock();mt_2.unlock();
}int main()
{std::thread t1(thread_task1);std::thread t2(thread_task2);t1.join();t2.join();return 0;
}

在验证中为了更容易复现死锁，我采用了 sleep(1) 的方法，这样容易保证出现持有且交叉申请的情况，即出现死锁。如果不适用 sleep(1) 的情况，死锁很难出现。我执行了多遍都没有出现，可见如果由于死锁的存在，你开发的程序很可能一直测试都是好的，有一天运行突然死锁了，就是这种低概率事件发生了（悲哀）。

// 线程 1
void func1()
{                       int done = 0;                   while(!done) {               LOCK(&mutex_a);                      if (TRYLOCK(&mutex_b)) {               counter++;                   UNLOCK(&mutex_b);                        UNLOCK(&mutex_a);                        done = 1;                        }                          else {                     UNLOCK(&mutex_a);                   }                          }
}                       // 线程 2
void func2()
{int done = 0;while(!done) {LOCK(&mutex_b);if (TRYLOCK(&mutex_a)) {counter++;UNLOCK(&mutex_a);UNLOCK(&mutex_b);done = 1; }else {UNLOCK(&mutex_b);}}
}

下面是我对活锁的验证：

#include <iostream>
#include <unistd.h>
#include <thread>
#include <mutex>
#include <vector>
#include <algorithm>
#include <functional>
#include <chrono>int counter = 0;
std::mutex mutex_1;
std::mutex mutex_2;void thread_task1()
{int done = 0;while(!done){mutex_1.lock();if(mutex_2.try_lock()) {//return -1 on successcounter++;mutex_2.unlock();mutex_1.unlock();done = 1;}   else{std::cout<<"is task 1 alive?"<<std::endl;mutex_1.unlock();}   }
}void thread_task2()
{int done = 0;while(!done){mutex_2.lock();if(mutex_1.try_lock()){counter++;mutex_1.unlock();mutex_2.unlock();done = 1;}else{std::cout<<"is task 2 alive?"<<std::endl;mutex_2.unlock();}}
}int main()
{std::thread t1(thread_task1);std::thread t2(thread_task2);t1.join();t2.join();return 0;
}

我使用 Python 的脚本去执行这段代码编译的可执行文件，基本上都是出现活锁。但是自己手动运行 ./main，活锁则很少出现，直到手动 N 次之后（手快残废了），活锁才出现，截图如下：

不停的 try lock 之后，两个线程各自获得了自己想要的锁，然后程序执行完毕了。不过由上述的 is task 1 alive 执行了很多遍，并且 is task 2 alive 也执行了多遍（截图没有展示出来，多遍有多少？反正我的屏幕一直往上滑都几屏幕都是这几句话），两个线程才获得各自的锁，程序才运行完毕，不用说，使用 try lock 可能造成的活锁对性能产生了不必要的延迟。

3. 锁竞争性能瓶颈

在多线程程序中锁竞争是最主要的性能瓶颈之一。在前面我们也提到过，通过使用锁来保护共享变量能防止数据竞跑，保证同一时刻只能有一个线程访问该临界区。但是我们也注意到，正是因为锁造成的对临界区的串行执行导致了并行程序的性能瓶颈。

3.1阿姆达尔法则（Amdahl’s Law）

  总体执行时间T = S + P/N

#include <iostream>
#include <thread>
#include <mutex>
#include <string>
#include <unistd.h>thread_local int counter = 0;
std::mutex mt; void thread_task(const std::string& thread_name)
{++counter;{   std::lock_guard<std::mutex> lock(mt);std::cout<<"counter for "<<thread_name<<" :"<<counter<<std::endl;}
}int main()
{std::thread t1(thread_task, "t1");std::thread t2(thread_task, "t2");{   std::lock_guard<std::mutex> lock(mt);std::cout<<"counter for main: "<<counter<<std::endl;  //注意同步cout，因为一个语句多次向缓冲区写，期间不能有其他线程写入}   t1.join();t2.join();return 0;
}

输出：

3.2.2 使用读写锁