首页 > 代码库 > 解释清楚智能指针二【用自己的话，解释清楚】
解释清楚智能指针二【用自己的话，解释清楚】
写在前面
用自己的话分析清楚~
智能指针是如何使用的？
强指针是如何实现？
弱指针如何转化为强指针？
智能指针的使用
智能指针的使用必须满足如下条件：
这个类需要继承自RefBase
为什么需要虚析构函数？
虚析构函数是为了解决这样的一个问题：基类的指针指向派生类对象，并用基类的指针删除派生类对象。虚函数的出现是为了解决多态问题。
满足上述条件的类就可以定义智能指针了，普通的指针使用如下方式：
MyClass *p_obj;
智能指针是这样定义：
Sp<MyClass> p_obj;
强指针的使用：
MyClass *p_obj;
1 p_obj = new MyClass(); // 注意不要写成 p_obj = new sp<MyClass>
2 sp<MyClass> p_obj2 = p_obj;
3 p_obj->func();
4 p_obj = create_obj();
5 some_func(p_obj);
弱指针的使用：
1 wp<MyClass> wp_obj = new MyClass();
2 p_obj = wp_obj.promote(); // 升级为强指针。不过这里要用.而不是->，真是有负其指针之名啊
3 wp_obj = NULL;
与普通指针相比，智能指针的特点
- 智能指针解决了对象自动释放的问题
- 智能指针其实更像引用
- 智能指针与普通指针相比，消耗更多的资源。
设计原理
智能指针是通过强弱引用计数来维护一个对象的生命周期的，如果强引用计数小于零的时候，会自动释放空间资源。
我们结合内部的实现，分析一下这段代码的执行：
- MyClass *p_obj;
- p_obj = new MyClass(); // 注意不要写成 p_obj = new sp<MyClass>
- sp<MyClass> p_obj2 = p_obj;
- p_obj->func();
- p_obj = create_obj();
- some_func(p_obj);
我们按照程序的执行流程来分析下内部代码的实现
源码位于：
http://androidxref.com/4.4.3_r1.1/xref/system/core/libutils/RefBase.cpp
http://androidxref.com/4.4.3_r1.1/xref/system/core/include/utils/RefBase.h
MyClass *p_obj;
p_obj = new MyClass(); // 注意不要写成 p_obj = new sp<MyClass>
MyClass继承自RefBase，所以：
579RefBase::RefBase()
580 : mRefs(new weakref_impl(this))
581{
582}
初始化了成员变量mRefs
70 weakref_impl(RefBase* base)
71 : mStrong(INITIAL_STRONG_VALUE)
72 , mWeak(0)
73 , mBase(base)
74 , mFlags(0)
75 {
76 }
62public:
63 volatile int32_t mStrong; //强引用计数
64 volatile int32_t mWeak; //弱引用计数
65 RefBase* const mBase;
66 volatile int32_t mFlags;
67
其中mFlags 用来描述对象的生命周期控制方式。取值可以使
131 //! Flags for extendObjectLifetime()
132 enum {
133 OBJECT_LIFETIME_STRONG = 0x0000, //只与强引用计数有关
134 OBJECT_LIFETIME_WEAK = 0x0001,
135 OBJECT_LIFETIME_MASK = 0x0001
136 };
（http://androidxref.com/4.4.3_r1.1/xref/system/core/include/utils/RefBase.h）
这里初始化了目标对象，对象内部初始化了强弱引用计数，及控制对象生命周期模式。
- sp<MyClass> p_obj2 = p_obj;
结合第一部分对sp实现的描述，
112template<typename T>
113sp<T>::sp(T* other)
114 : m_ptr(other) {
115 if (other)
116 other->incStrong(this);
117}
使用传递来的形参初始化m_ptr， 这其实是对目标对象多了一次引用，所以这里调用incStrong(this)来增加一个强引用计数。
318void RefBase::incStrong(const void* id) const
319{
320 weakref_impl* const refs = mRefs;
321 refs->incWeak(id);
322
323 refs->addStrongRef(id);
324 const int32_t c = android_atomic_inc(&refs->mStrong);
325 ALOG_ASSERT(c > 0, "incStrong() called on %p after last strong ref", refs);
326#if PRINT_REFS
327 ALOGD("incStrong of %p from %p: cnt=%d\n", this, id, c);
328#endif
329 if (c != INITIAL_STRONG_VALUE) {
330 return;
331 }
332 //如果等于初值，说明是第一次，则先减去初值。调用函数onFirstRef（）
333 android_atomic_add(-INITIAL_STRONG_VALUE, &refs->mStrong);
334 refs->mBase->onFirstRef();
335}
In RefBase.cpp 实现，用户的程序中，如有需要可重载之。
610void RefBase::onFirstRef()
611{
612}
387void RefBase::weakref_type::incWeak(const void* id)
388{
389 weakref_impl* const impl = static_cast<weakref_impl*>(this);
390 impl->addWeakRef(id);
391 const int32_t c = android_atomic_inc(&impl->mWeak);
392 ALOG_ASSERT(c >= 0, "incWeak called on %p after last weak ref", this);
393}
68#if !DEBUG_REFS
69
70 weakref_impl(RefBase* base)
71 : mStrong(INITIAL_STRONG_VALUE)
72 , mWeak(0)
73 , mBase(base)
74 , mFlags(0)
75 {
76 }
77
78 void addStrongRef(const void* /*id*/) { }
79 void removeStrongRef(const void* /*id*/) { }
80 void renameStrongRefId(const void* /*old_id*/, const void* /*new_id*/) { }
81 void addWeakRef(const void* /*id*/) { }
82 void removeWeakRef(const void* /*id*/) { }
83 void renameWeakRefId(const void* /*old_id*/, const void* /*new_id*/) { }
84 void printRefs() const { }
85 void trackMe(bool, bool) { }
86
87#else
我们看到在release版本中addWeakRef(const void* /*id*/)等为空函数。
由调用系统函数android_atomic_inc（） 实现对&impl->mWeak增加。
最终的计数单元其实是在对象中的weakref_type* m_refs;中的mWeak，mStrong.
接下来我们看随着sp指针作用域的结束，其调用自身的析构函数对对象内的计数自减操作。
下面看sp的析构函数的定义
http://androidxref.com/4.4.3_r1.1/xref/system/core/include/utils/StrongPointer.h
140template<typename T>
141sp<T>::~sp() {
142 if (m_ptr)
143 m_ptr->decStrong(this);
144}
337void RefBase::decStrong(const void* id) const
338{
339 weakref_impl* const refs = mRefs;
340 refs->removeStrongRef(id);
341 const int32_t c = android_atomic_dec(&refs->mStrong);
342#if PRINT_REFS
343 ALOGD("decStrong of %p from %p: cnt=%d\n", this, id, c);
344#endif
345 ALOG_ASSERT(c >= 1, "decStrong() called on %p too many times", refs);
346 if (c == 1) {
//这里说明引用的次数已经为0，android_atomic_dec（）函数返回的是执行之前的值。
//调用对象的结束前的函数onLastStrongRef(id);
//释放对象
347 refs->mBase->onLastStrongRef(id);
348 if ((refs->mFlags&OBJECT_LIFETIME_MASK) == OBJECT_LIFETIME_STRONG) {
349 delete this;
350 }
351 }
352 refs->decWeak(id);
353}
整体分析下来，感觉智能指针的整个代码还是比较简单和清晰的。强弱引用计数具体的计数操作是在每个对象中的成员变量:weakref_impl类型的mrefs实现的。weakref_impl 类型继承自RefBase::weakref_type，RefBase::weakref_type其中定义了具体技术的实现，使用变量存储强弱引用计数，使用android系统提供的原子操作对这些变量进行加减。提供封装出变量的增加，减少函数供智能指针中的引用计数函数调用。 智能指针利用封装的模板类的构造函数和析构函数自动的调用计数函数实现对对象的调用管理，当引用次数为0时，释放对象空间。
RefBase同时定义了函数
145 virtual void onFirstRef();
146 virtual void onLastStrongRef(const void* id);
147 virtual bool onIncStrongAttempted(uint32_t flags, const void* id);
148 virtual void onLastWeakRef(const void* id);
分别定义了第一次引用对象的时候执行的函数onFirstRef();
最后一次强引用对象时的函数onLastStrongRef(const void* id);
最后一次弱引用对象时的函数onLastWeakRef(const void* id);
在看看 wp弱指针
// 这个函数用于将wp指针升级为sp指针
//其主要判断m_ptr所指向的对象是否已经释放以及是否可以增加强指针计数
//如果ok，则返回强指针
440template<typename T>
441sp<T> wp<T>::promote() const
442{
443 sp<T> result;
444 if (m_ptr && m_refs->attemptIncStrong(&result)) {
445 result.set_pointer(m_ptr);
446 }
447 return result;
448}
428bool RefBase::weakref_type::attemptIncStrong(const void* id)
429{
430 incWeak(id);
431
432 weakref_impl* const impl = static_cast<weakref_impl*>(this);
433 int32_t curCount = impl->mStrong;
434
435 ALOG_ASSERT(curCount >= 0,
436 "attemptIncStrong called on %p after underflow", this);
437
438 while (curCount > 0 && curCount != INITIAL_STRONG_VALUE) {
439 // we‘re in the easy/common case of promoting a weak-reference
440 // from an existing strong reference.
441 if (android_atomic_cmpxchg(curCount, curCount+1, &impl->mStrong) == 0) {
442 break;
443 }
444 // the strong count has changed on us, we need to re-assert our
445 // situation.
446 curCount = impl->mStrong;
447 }
一个弱指针所引用的对象，可能处于两种情况。第一种情况该对象同时也被其他对象引用（此时其mStrong值应大于0，且不等于初值INITIAL_STRONG_VALUE）对于这种情况比较好处理。
因为同一个对象可能有多个对象在引用，所以这里加了这么多判断主要是为了 数据的同步。
448
449 if (curCount <= 0 || curCount == INITIAL_STRONG_VALUE) {
450 // we‘re now in the harder case of either:
451 // - there never was a strong reference on us
452 // - or, all strong references have been released
453 if ((impl->mFlags&OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_STRONG) {
454 // this object has a "normal" life-time, i.e.: it gets destroyed
455 // when the last strong reference goes away
456 if (curCount <= 0) {
457 // the last strong-reference got released, the object cannot
458 // be revived.
459 decWeak(id);
460 return false;
461 }
462
463 // here, curCount == INITIAL_STRONG_VALUE, which means
464 // there never was a strong-reference, so we can try to
465 // promote this object; we need to do that atomically.
466 while (curCount > 0) {
467 if (android_atomic_cmpxchg(curCount, curCount + 1,
468 &impl->mStrong) == 0) {
469 break;
470 }
471 // the strong count has changed on us, we need to re-assert our
472 // situation (e.g.: another thread has inc/decStrong‘ed us)
473 curCount = impl->mStrong;
474 }
475
476 if (curCount <= 0) {
477 // promote() failed, some other thread destroyed us in the
478 // meantime (i.e.: strong count reached zero).
479 decWeak(id);
480 return false;
481 }
482 } else {
483 // this object has an "extended" life-time, i.e.: it can be
484 // revived from a weak-reference only.
485 // Ask the object‘s implementation if it agrees to be revived
486 if (!impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id)) {
487 // it didn‘t so give-up.
488 decWeak(id);
489 return false;
490 }
491 // grab a strong-reference, which is always safe due to the
492 // extended life-time.
493 curCount = android_atomic_inc(&impl->mStrong);
494 }
495
496 // If the strong reference count has already been incremented by
497 // someone else, the implementor of onIncStrongAttempted() is holding
498 // an unneeded reference. So call onLastStrongRef() here to remove it.
499 // (No, this is not pretty.) Note that we MUST NOT do this if we
500 // are in fact acquiring the first reference.
501 if (curCount > 0 && curCount < INITIAL_STRONG_VALUE) {
502 impl->mBase->onLastStrongRef(id);
503 }
504 }
505
506 impl->addStrongRef(id);
507
508#if PRINT_REFS
509 ALOGD("attemptIncStrong of %p from %p: cnt=%d\n", this, id, curCount);
510#endif
511
512 // now we need to fix-up the count if it was INITIAL_STRONG_VALUE
513 // this must be done safely, i.e.: handle the case where several threads
514 // were here in attemptIncStrong().
515 curCount = impl->mStrong;
516 while (curCount >= INITIAL_STRONG_VALUE) {
517 ALOG_ASSERT(curCount > INITIAL_STRONG_VALUE,
518 "attemptIncStrong in %p underflowed to INITIAL_STRONG_VALUE",
519 this);
520 if (android_atomic_cmpxchg(curCount, curCount-INITIAL_STRONG_VALUE,
521 &impl->mStrong) == 0) {
522 break;
523 }
524 // the strong-count changed on us, we need to re-assert the situation,
525 // for e.g.: it‘s possible the fix-up happened in another thread.
526 curCount = impl->mStrong;
527 }
528
529 return true;
530}
这里结合代码分析下，弱指针升级为强指针的过程。
这块随后补上~
QQ群 计算机科学与艺术 272583193
加群链接：http://jq.qq.com/?_wv=1027&k=Q9OxMv