C++多线程系统编程

线程安全的对象生命期管理

编写线程安全的类不是难事，使用同步原语保护内部状态即可。但是对象的生与死不能由对象自身拥有的 mutex 来保护。如何避免对象析构时可能存在的 race condition 是 C++ 多线程编程面临的基本难题。

应了解 互斥器、竞争条件、智能指针、Observer设计模式。

1. 当析构函数遇到多线程

C++要求程序员自己管理对象的生命期，这在多线程环境下显得尤为困难。当一个对象能被多个线程同时看到时，那么对象的销毁时机就会变得模糊不清，可能出出现多种race condition：

• 在即将析构一个对象时，从何知道此刻是否有别的线程正在执行该对象的成员函数？
• 如何保证在执行成员函数期间，对象不会在另一个线程被析构？
• 在调用某个对象的成员函数之前，如何得知这个对象还活着？它的析构函数会不会碰巧执行到一半？

1.1 线程安全的定义

一个线程安全的class应当满足以下三个条件：

• 多个线程同时访问时，其表现出正确的行为；
• 无论操作系统如何调用这些线程，无论这些线程的执行顺序如何交织；
• 调用端代码无须额外的同步或其他协调动作。

根据这个定义，C++标准库的大多数class都不是线程安全的，包括 std::string、std::vector、std::map 等，因为这些class通常需要在外部加锁才能供多个线程同时访问。

1.2 MutexLock 与 MutexLockGuard

https://blog.csdn.net/KangRoger/article/details/47067801

2. 对象的创建很简单

对象构造要做到线程安全，唯一的要求就是在构造期间不要泄露this指针：

• 不要在构造函数中注册任何回调函数；
• 也不要在构造函数中把this传给跨线程的对象；
• 即便在构造函数的最后一行也不行。

是因为在构造函数执行期间对象还没有完成初始化，如果this指针被泄露给了其他对象，那么别的线程有可能访问这个半成品对象，会造成难以预料的后果。

//不要这么做
class Foo : public Observer
{
public:
  Foo(Observable* s)
  {
    s->register_(this);  //错误，非线程安全
  }
  virtual void update();
}

//要这么做
class Foo : public Observer
{
public:
  Foo();
  virtual void update();

  //另外定义一个函数，在构造之后执行回调函数的注册工作
  void obeserve(Observable* s)
  {
    s->register_(this);  
  }
};

Foo* pFoo = new Foo;
Observable* s = getSubject();
pFoo->observe(s);  //二段式的构造

相对来说，对象的构造做到线程安全还是比较容易的。

3. 销毁太难

作为class数据成员的MutexLock只能用于同步本class的其他数据成员的读和写，它不能保护安全的析构。因为MutexLock成员的生命期最多与对象一样长，而析构动作可以说是发生在对象身故之后（或者身亡之时）。

另外，对于基类对象，那么调用到基类析构函数的时候，派生类对象的那部分已经析构，那么基类所拥有的MutexLock不能保护整个析构过程。

再说，析构过程本来也不需要保护，因为只有别的线程都访问不到这个对象时，析构才是安全的，否则会发生竞态条件。

另外如果要同时读写一个class的两个对象，有潜在的死锁可能。如果一个函数要锁住相同类型的对个对象，为了保证始终按相同的顺序加锁，我们可以比较mutex对象的地址，始终线加锁地址较小的mutex。

4. 线程安全的Observeer有多难

一个动态创建的对象的是否还活着，光看指针时看不出来的。指针就是指向一块内存，这款内存的对象如果已经销毁，那么就根本不能访问，所以根据这个去判断是没有意义的。

在面向对象程序设计中，对象的关系主要有三种：composition（组合）、aggregation（聚合）、association（关联）。后两种关系，它表示一个对象a用到了另一个对象b，调用了后者的成员函数，从代码形式上看，a持有b的指针，但是b的生命周期不由a单独控制，如果b是动态创建的，并在整个程序结束前有可能被释放，那么就会出现竞态条件。

那么似乎可以只创建不销毁，程序使用一个对象池来暂存用过的对象，下次申请对象时，如果对象池里面有存货，久重复利用，否则就新建一个。对象用完了，不是直接释放，而是放回池子里。但是这种方法也有缺点：

• 对象池的线程安全，如何安全地、完整地把对象放回池子里，防止出现“部分放回”的竞态？（A线程认为对象x已经放回了，B认为对象x还活着。）
• 全局共享数据引发的lock contention，这个集中化的对象池会不会把多线程并发的操作串行化？
• 会不会造成内存泄露与分片？因为对象池占用的内存只增不减，而且对象池不能共享内存。

5. 原始指针有何不妥

指向对象的原始指针是坏的，尤其当暴露给别的线程时。Observable应当保存的不是原始的Observer*，而是别的什么东西，能分辨Observer对象是否还活着。

6. 神器 shared_ptr/weak_ptr

shared_ptr 是引用计数型智能指针，当引用计数降为0时，对象被销毁。weak_ptr 也是一个引用计数型智能指针，但是它不增加对象的引用次数，即弱引用。

7. 系统的避免各种指针错误

C++里可能出现的内存问题大致有几个方面：

• 缓冲区溢出
• 空悬指针、野指针
• 重复释放
• 内存泄露
• 不配对的new和delete
• 内存碎片

正确使用智能指针可以很轻易地解决前面5个问题，第6个问题需要别的思路。

• 缓冲区溢出：用std::vector/std::string来管理缓冲区，自动记录缓冲区的长度，并通过成员函数而不是裸指针来修改缓冲区。
• 空悬指针、野指针：使用shared_ptr活着weak_ptr
• 重复释放：使用scoped_ptr，只在对象析构的时候释放一次。
• 内存泄露：用scoped_ptr，对象析构的时候自动释放内存。
• 不配对的new和delete：把new替换成std::vector/scoped_array。