多线程对构造函数和析构函数的影响

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

1）不要在构造函数中注册任何回调函数。

2）不要在构造函数中把this指针传给跨线程的对象。

3）即便在构造函数的最后一行也不行。

之所以这样是因为在构造函数执行期间对象还没有完成初始化，访问这样的对象会出现难以预料的结果。

对于析构函数，如果是单线程，只需注意避免空悬指针（对象已经销毁）和野指针（未初始化的指针）。而多线程时，就需要考虑很多因素了。一个动态创建的对象是否仍有效，光看指针是看不出来的。判断一个指针是不是合法指针没有高效的办法，这是C/C++指针问题的根源。指向对象的原始指针是坏的，尤其当暴露给别的线程时，一个好的解决方法是使用引用计数型智能指针，即boost中的shared_ptr/weak_ptr。shared_ptr是强引用，控制对象的生命期；weak_ptr是若引用，不增加对象的引用次数，但是它知道对象是否还活着。如果对象还活着，那么它可以提升为有效的share_ptr，如果对象已经死了，提升会失败，返回一个空的shared_ptr。shared_ptr是管理共享资源的利器，需要注意避免循环引用，通常的做法是ower持有执行child的shared_ptr，child持有指向owner的weak_ptr。下面以Observer模式为例。

Observable.h

#ifndef OBSERVABLE_H
#define OBSERVABLE_H
#include <boost/weak_ptr.hpp>
#include <vector>
#include <string>
using namespace std;
using namespace boost;
class Observer;
class Observable{
public:
   Observable();
   ~Observable();
   void registe(weak_ptr<Observer>);
   void unregiste(weak_ptr<Observer>);
   void notifyAll();
   void setData(string,string);
private:
   vector<weak_ptr<Observer> > observe;
   string weather;
   string humidity;
};
#endif

Observable.cpp

#include "Observable.h"
#include "Observer.h"  //一定要包含，否则前项申明也不行
Observable::Observable(){
   
}
Observable::~Observable(){
    
}
void Observable::registe(weak_ptr<Observer> obs){
   observe.push_back(obs);
}
void Observable::unregiste(weak_ptr<Observer> obs){
   std::vector<weak_ptr<Observer> >::iterator it = observe.begin();
   while(!(*(*it).lock() == *obs.lock())){
      ++it;
   }
  observe.erase(it);
}
void Observable::notifyAll(){
   std::vector<weak_ptr<Observer> >::iterator it = observe.begin();
   while(it != observe.end()){
   shared_ptr<Observer> obj(it->lock());
      if(obj){
         obj->update(weather,humidity);
     ++it;
      }
      else
         it = observe.erase(it);
   }
}
void Observable::setData(string wea,string hum){
   weather = wea;
   humidity = hum;
   notifyAll();
}

Observer.h

#ifndef OBSERVER_H
#define OBSERVER_H
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
using namespace std;
using namespace boost;
class Observable;
class Observer:public enable_shared_from_this<Observer>{
public:
   Observer(shared_ptr<Observable>);
   void obser(shared_ptr<Observable>);
   bool operator==(const Observer&);
   ~Observer();
   void update(string,string);
private:
   shared_ptr<Observable> subject;
};
#endif

Observer.cpp

#include "Observer.h"
#include "Observable.h"
#include <iostream>
using namespace std;
using namespace boost;
Observer::Observer(shared_ptr<Observable> sub):subject(sub){
}
void Observer::obser(shared_ptr<Observable> s){
   
   (*s).registe(shared_from_this());
}
Observer::~Observer(){
}
bool Observer::operator==(const Observer& obs){
   return *this == obs;
}
void Observer::update(string wea,string hum){
   cout<<"Weather is "<<wea<<" and Humidity is "<<hum<<"\n";
}

testObser.cpp

#include "Observable.h"
#include "Observer.h"
int main(){
   shared_ptr<Observable> subject(new Observable);
   shared_ptr<Observer> p(new Observer(subject));
   p->obser(subject);
   
   subject->setData("Fine","Mid");
   subject->setData("Bad","High");
   return 0;
}

这里需要注意shared_ptr循环引用的情况，此处使用weak_ptr来消除此隐患。