再扯扯智能指针之protobuf

namespace google {
namespace protobuf {
namespace internal {
#if !defined(UTIL_GTL_USE_STD_SHARED_PTR) && \
    (defined(COMPILER_MSVC) || defined(LANG_CXX11))
#define UTIL_GTL_USE_STD_SHARED_PTR 1
#endif

#if defined(UTIL_GTL_USE_STD_SHARED_PTR) && UTIL_GTL_USE_STD_SHARED_PTR
using std::enable_shared_from_this;
using std::shared_ptr;
using std::static_pointer_cast;
using std::weak_ptr;
#else
//自定义的智能指针实现
#endif
}
}
}

class SharedPtrControlBlock {
  template <typename T> friend class shared_ptr;
  template <typename T> friend class weak_ptr;
 private:
  SharedPtrControlBlock() : refcount_(1), weak_count_(1) { }
  Atomic32 refcount_;
  Atomic32 weak_count_;
};

  T* ptr_;
  SharedPtrControlBlock* control_block_;

shared_ptr() : ptr_(NULL), control_block_(NULL) {}

  explicit shared_ptr(T* ptr)
      : ptr_(ptr),
        control_block_(ptr != NULL ? new SharedPtrControlBlock : NULL) {
    // If p is non-null and T inherits from enable_shared_from_this, we
    // set up the data that shared_from_this needs.
    MaybeSetupWeakThis(ptr);
  }

  void MaybeSetupWeakThis(enable_shared_from_this<T>* ptr);
  void MaybeSetupWeakThis(...) { }

  template <typename U, typename V>
  void InitializeWithStaticCast(const shared_ptr<V>& r) {
    if (r.control_block_ != NULL) {
      RefCountInc(&r.control_block_->refcount_);

      ptr_ = static_cast<U*>(r.ptr_);
      control_block_ = r.control_block_;
    }
  }

  ~shared_ptr() {
    if (ptr_ != NULL) {
      //首先判断refcount_减1的值
      //如果为0，表示自己是最后一个own原始指针的智能指针，需要释放ptr_
      if (!RefCountDec(&control_block_->refcount_)) {
        delete ptr_;

        // weak_count_ is defined as the number of weak_ptrs that observe
        // ptr_, plus 1 if refcount_ is nonzero.
        if (!RefCountDec(&control_block_->weak_count_)) {
          delete control_block_;
        }
      }
    }
  }

class sp_counted_base
{
private:
    ...

    int use_count_;        // #shared
    int weak_count_;       // #weak + (#shared != 0)

  element_type* ptr_;
  SharedPtrControlBlock* control_block_;

  void CopyFrom(T* ptr, SharedPtrControlBlock* control_block) {
    //复制成员变量：ptr_ control_block_
    ptr_ = ptr;
    control_block_ = control_block;
    if (control_block_ != NULL)
      //增加引用计数
      RefCountInc(&control_block_->weak_count_);
  }

  shared_ptr<T> lock() const {
    shared_ptr<T> result;
    if (control_block_ != NULL) {
      Atomic32 old_refcount;
      do {
        old_refcount = control_block_->refcount_;
        //如果refcount_ == 0，表示没有shared_ptr在管理ptr_，ptr_已经释放
        if (old_refcount == 0)
          break;
        //while这句非常关键，注意这种race condition
        //最后一个shared_ptr将refcount_置0，然后析构ptr_
        //此时执行while前control_block_->refcount_ = 0， old_refcount = 1
        //因此除了Swap，Compare是必须的
      } while (old_refcount !=
               NoBarrier_CompareAndSwap(
                   &control_block_->refcount_, old_refcount,
                   old_refcount + 1));
      if (old_refcount > 0) {
        result.ptr_ = ptr_;
        result.control_block_ = control_block_;
      }
    }

    return result;
  }

Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
                                  Atomic32 old_value,
                                  Atomic32 new_value)
// Atomically execute:
      result = *ptr;
      if (*ptr == old_value)
        *ptr = new_value;
      return result;

if (old_refcount > 0) {
  RefCountInc(&control_block_->refcount_);
}

      if (!RefCountDec(&control_block_->refcount_)) {
        delete ptr_;

  // Return a shared_ptr that owns the object we are observing. If we
  // have expired, the shared_ptr will be empty. We have to be careful
  // about concurrency, though, since some other thread might be
  // destroying the last owning shared_ptr while we're in this
  // function.  We want to increment the refcount only if it's nonzero
  // and get the new value, and we want that whole operation to be
  // atomic.

if (old_refcount > 0) {
  RefCountInc(&control_block_->refcount_);
}
if (control_block->refcount_ == 1) {
  //自己是最后一个，无效内存
} else {
  //有效？
}

class LinkBaseReader : public boost::enable_shared_from_this<LinkBaseReader>

  weak_ptr<T> weak_this_;

template<typename T>
void shared_ptr<T>::MaybeSetupWeakThis(enable_shared_from_this<T>* ptr) {
  if (ptr) {
    CHECK(ptr->weak_this_.expired()) << "Object already owned by a shared_ptr";
    ptr->weak_this_ = *this;
  }
}

  shared_ptr<T> shared_from_this() {
    CHECK(!weak_this_.expired()) << "No shared_ptr owns this object";
    return weak_this_.lock();
  }

template <typename T, typename U>
shared_ptr<T> static_pointer_cast(const shared_ptr<U>& rhs) {
  shared_ptr<T> lhs;
  lhs.template InitializeWithStaticCast<T>(rhs);
  return lhs;
}

  template <typename U, typename V>
  void InitializeWithStaticCast(const shared_ptr<V>& r)

  lhs.InitializeWithStaticCast<T>(rhs);