条款49：了解new-handle行为

多线程下的内存管理与单线程下是完全不同的，因为heap是一个可以被全局改动的资源，所以所有的线程都有可能去访问这一资源，这回导致很多的race_conditions。

 

当operator new未取得想要的内存的时候，会调用一个用户指定的处理函数，new_handler。 这个函数可以使用set_new_handler来进行指定。

 namespace std{
     typedef void(*new_handler)();//没有参数以及返回值
     new_handler set_new_handler(new_handler p) throw();
 }

当operator new无法满足内存申请条件的时候，其就会不停的调用new-handler函数，所以说一个设计良好的new-handler应该需要满足下面的要求：

    让更多的内存被使用

    当当前的handler无法满足条件的时候，安装另一个new-handler.

    卸除new_handler，将null指针传给set_new_handler，，此时operator new 在无法分配内存的时候就会抛出异常

    抛出bad_alloc异常：这样的异常会被传播到内存的索求处

    不返回：调用abort或者exit

 

 

当需要以不同的方式去处理不同的class内存分配失败的情况的时候，应该为相应的特殊的class提供自己的set_new_handler以及operator_new。这样operator new会在分配内存的时候确保使用class专属的new_handler替代global的new handler.

 

一个Widget分配资源的简单例子：

 class NewHandlerHolder{
 public:
     explicit NewHandlerHolder(std::new_handler nh)
     :handler(nh){}
     ~NewHandlerHolder()
     std::set_new_handler(handler);    //将状态恢复到之前的状态
 private:
     new_handler handler;
     NewHandlerHolder(const NewHandlerHolder &);    //禁止这两种操作
     NewHandlerHolder & operator(const NewHandlerHolder &);
 };

上面这个就可以被自定义的一个类所使用了：

 void * Widget::operator new(std::size_t size) throw (std::bad_alloc)
 {
     NewHandlerHolder h(std::set_new_handler(currentHandler));//使用上面的RAII将handler资源正确的管理。
     return ::operator new(size);//使用自定义的new
 }

实际上，可以将上面的NewHandlerHolder设计成为一个基类模板，这样derived_class科技继承他们需要的set_new_handler以及operator_new,template用于保证每一个derived_class获得一个实体互异的currentHandler成员变量。下为这个模板：

 template<typename T>   //这里的typename T 并未被使用，作用下面会说
 class NewHandlerSupport{
 public:
     static std::new_handler set_new_handler(std::new_handler p) throw();
     static void * operator new(std::size_t size) throw(std::bad_alloc);
     ...
 private:
     static std::new_handler currentHandler;
 };
 template<typename T>
 static std::new_handler
 NewHandlerSupport<T> set_new_handler(std::new_handler p) throw()
 {
     std::new_handler oldHandler = currentHandler;
     currentHandler = p;
     return oldHandler;
 }
 template<typename T>
 static void *
 NewHandlerSupport<T>::operator new(std::size_t size) throw(std::bad_alloc)
 {
     NewHandlerHolder h(std::set_new_handler(currentHandler));
     return ::operator(size);//调用全局的operatornew,防止递归的调用自己。
 }

有了这个模板，那么为Widget提供专属的set_new_handler以及operator都是很容易的了。继承上面的模板并特例化就可以了：

 class Widget : public NewHandlerSupport<Widget>{
     ...
 };

这样就有了专属的set_new_handler以及operator new。

上买了的typename T 没有被使用，实际上也不需要， 这个T的目的只是为了使得不同的继承自NewHandlerSupport的子类有着其不同的实例函数。（主要是为了static变量，currentHandler）。T只是用来区分不同的derived_class. (因为上面T实例化成了Widget)

 

还有就是关于nothrow的问题，使用new (std::nothrow) Widget不会在new上产生异常，只会返回一个null指针，但是如果new正常还有可能在构造过程中产生异常，因此依然没有异常保证。没事不要用new (std::nothrow) sth;

 

小结：

    set_new_handler允许用户指定一个函数在内存无法分配时调用

    Nothrow new只能保证new不抛异常，构造仍然得不到保证。