Android智能指针sp wp详解

原文：http://blog.csdn.net/lizhiguo0532/article/details/6260114

研究Android的时候，经常会遇到sp、wp的东西，网上一搜，原来是android封装了c++中对象回收机制。
说明：
1. 如果一个类想使用智能指针，那么必须满足下面两个条件：
a. 该类是虚基类RefBase的子类或间接子类
b. 该类必须定义虚构造函数。如virtual ~MyClass();

2. 本文以类BBinder来进行说明，其余类使用sp或wp的情况类似
3. 代码路径：frameworks/base/libs/utils/RefBase.cpp
frameworks/base/include/utils/RefBase.h

一、calss BBinder类说明
class RefBase
class IBinder
class BpBinder class BBinder
class BBinder : public IBinder
{
...
protected:
virtual ~BBinder();
...
}
class IBinder : public virtual RefBase
{
...
protected:
inline virtual ~IBinder() { }
...
}
由上，可以看出BBinder和IBinder都是以public的方式继承于虚基类RefBase的。

二、sp wp对象的建立过程
解析：sp<BBinder> BB_ptr(new BBinder);
这是一条定义sp指针BB_ptr的语句，他只想的对象是一个BBinder对象。
如图所示。

1》首先看一下new BBinder时都做了什么，特别是和该机制相关的初始化。
c++中创建一个对象时，需要调用去构造函数，对于继承类，则是先调用其父类的构造函数，然后才会调用本身的
构造函数。这里new一个BBinder对象时，顺序调用了：
RefBase::RefBase() : mRefs(new weakref_impl(this)) {}
inline IBinder() {}
BBinder::BBinder() : mExtras(NULL){}
主要关注的是RefBase的构造函数，
可以看出他是通过new weakref_impl(this)的结果来初始化私有成员mRefs
这里的this指向BBinder对象自身，class weakref_impl继承于类RefBase的内嵌类weakref_type，然后该类
weakref_impl又被类RefBase引用。类weakref_impl的构造函数如下：
weakref_impl(RefBase* base)
: mStrong(INITIAL_STRONG_VALUE)// 1 << 28
, mWeak(0)
, mBase(base)// new BBinder指针
, mFlags(0)
, mStrongRefs(NULL)// sp引用链表指针
, mWeakRefs(NULL)// wp引用链表指针
, mTrackEnabled(!!DEBUG_REFS_ENABLED_BY_DEFAULT) // 1
, mRetain(false) {}

2》new BBinder返回的是BBinder对象的指针，如：sp<BBinder> BB_ptr(0x????????);
sp实际上是一个类模板，这条语句最终是要建立一个sp的实例化对象，叫模板类BB_ptr
这里生成BB_ptr对象所调用的构造函数是：
template<typename T>
sp<T>::sp(T* other)
: m_ptr(other)
{
if (other) other->incStrong(this);
}
BB_ptr对象的私有指针指向刚刚前面生成的BBinder对象。
接着调用函数incStrong(),该函数是RefBase类的成员函数，在子类中没有被重载，所以这里
other->incStrong(this)的调用实际上是调用基类成员函数incStrong(this)，这个this值是指向sp对象
BB_ptr的指针。现在转去查看该成员函数的实现。

void RefBase::incStrong(const void* id) const
{
weakref_impl* const refs = mRefs;
/* 取得BBinder对象基类中的私有只读指针mRefs */
refs->addWeakRef(id);
/* 调用weakref_impl类定义时实现的成员函数addWeakRef， 见下注释1*/
refs->incWeak(id);
/* 调用weakref_impl类的基类weakref_type成员函数incWeak， 见下注释2*/

refs->addStrongRef(id);
// 调用weakref_impl类定义时实现的成员函数addStrongRef， 见下注释1
const int32_t c = Android_atomic_inc(&refs->mStrong);
/* 该函数实际将refs->mStrong值加1，也就是增加强引用计数值。但是返回值为refs->mStrong-1 */
LOG_ASSERT(c > 0, "incStrong() called on %p after last strong ref", refs);
#if PRINT_REFS
LOGD("incStrong of %p from %p: cnt=%d\n", this, id, c);
#endif
if (c != INITIAL_STRONG_VALUE) {
return;
}
/* c = INITIAL_STRONG_VALUE, 第一个强引用产生的时候才会出现这个情况 */
Android_atomic_add(-INITIAL_STRONG_VALUE, &refs->mStrong);
/* 返回值为INITIAL_STRONG_VALUE，refs->mStrong值变成1 */
const_cast<RefBase*>(this)->onFirstRef();
}

/************************注释1********************************/
void addWeakRef(const void* id)
{
addRef(&mWeakRefs, id, mWeak);
}
void addStrongRef(const void* id)
{
addRef(&mStrongRefs, id, mStrong);
}
addRef()是类weakref_impl的私有成员函数，addWeakRef()函数引用的是public成员变量，而addRef()函数可以操作私有数据。

struct ref_entry
{
ref_entry* next;
const void* id;
int32_t ref;
};

void addRef(ref_entry** refs, const void* id, int32_t mRef)
{
if (mTrackEnabled) {
AutoMutex _l(mMutex);
ref_entry* ref = new ref_entry;
ref->ref = mRef;
ref->id = id;

ref->next = *refs;
*refs = ref;
/*
新出现的ref_entry结构体加入到链表头上，如果有n个sp指针指向同一个目标对象
那么这里就有n个ref_entry结构体加入到这个单链表中，该结构体记录着如下数据
1. id域记录着对应的sp强指针类对象的this值
2. ref域记录的是当前sp强指针类对象是第几个引用目标对象的指针
3. next域指向下一个指向目标对象的sp强指针对应的ref_entry结构体

类RefBase的嵌套类weakref_type的子类的私有数据mRefs的私有二级指针成员mWeakRefs指向的是
最后一个sp强指针对应的ref_entry结构体指针。

总结一下:
一个目标对象，可能被n个sp强指针指向，那么就存在n个class sp对象，同时每一个sp
对象在目标对象的虚基类对象的成员类mRefs的私有二级指针成员mWeakRefs登记了一个
ref_entry结构体，这些ref_entry结构体的地址都是由该链表管理，每一个
ref_entry结构体和哪一个sp对象对应，也由该链表管理。同时链接数就是该链表节点的
个数
*/
}
}
/************************注释1********************************/

/************************注释2********************************/
void RefBase::weakref_type::incWeak(const void* id)
{
weakref_impl* const impl = static_cast<weakref_impl*>(this);
// 强制类型转换，将基类指针转换成子类指针
impl->addWeakRef(id);
// 调用类weakref_impl成员函数addWeakRef()，产生一个ref_entry结构体挂载mWeakRefs链表上
const int32_t c = Android_atomic_inc(&impl->mWeak);
/* impl->mWeak加1，表示已存在一个weak引用。但返回值c为操作前的结果 */
LOG_ASSERT(c >= 0, "incWeak called on %p after last weak ref", this);
}
/************************注释2********************************/

3》上面是定义一个sp指针，下面看看定义一个wp指针式如何实现的。
wp<BBinder> BB_wp_ptr(BB_ptr);
下面是wp类对应上面定义类型的构造函数
template<typename T>
wp<T>::wp(const sp<T>& other)
: m_ptr(other.m_ptr)
{
if (m_ptr) {
m_refs = m_ptr->createWeak(this);
}
}
this指针是指向wp对象的。createWeak()函数是RefBase类的成员函数。
RefBase::weakref_type* RefBase::createWeak(const void* id) const
{
mRefs->incWeak(id);
return mRefs;
}
mRefs指向的是第二步骤中产生的weakref_impl对象，调用基类weakref_type的成员函数incWeak()
void RefBase::weakref_type::incWeak(const void* id)
{
weakref_impl* const impl = static_cast<weakref_impl*>(this);
impl->addWeakRef(id);
const int32_t c = Android_atomic_inc(&impl->mWeak);
/* impl->mWeak有加1，但返回值为操作前的结果 */
LOG_ASSERT(c >= 0, "incWeak called on %p after last weak ref", this);
}

三、sp、wp释放过程
sp<BBinder> BB_SP_ptr(BB_ptr);
实际上BB_SP_ptr和前面的BB_ptr一样，指向的是同一个BBinder对象。另外需要注意的时，调用sp构造函数：
template<typename T>
sp<T>::sp(const sp<T>& other)
: m_ptr(other.m_ptr)
{
if (m_ptr) m_ptr->incStrong(this);
}
同样是需要调用BBinder对象的incStrong()函数，使用weakref_impl对象来管理新添加进来的强引用，同时增加一个
ref_entry结构体到weakref_impl对象的mStrongRefs，增加2个ref_entry结构体到weakref_impl对象的mWeakRefs。
如上图所示。

现在来看看释放sp、wp指针的情况。
delete BB_SP_ptr;
将会调用如下形式的sp析构函数：
template<typename T>
sp<T>::~sp()
{
if (m_ptr) m_ptr->decStrong(this);
}
m_ptr指向的是前面生成的BBinder对象，调用其基类函数decStrong(this)，this值是指向BB_SP_ptr对象。

void RefBase::decStrong(const void* id) const
{
weakref_impl* const refs = mRefs;
refs->removeStrongRef(id); // 注释3，移除mStrongRefs链表中和该sp对应的ref_entry结构体
const int32_t c = Android_atomic_dec(&refs->mStrong);
/* 强引用计数减1， 但返回的是操作之前的引用计数值 */
LOG_ASSERT(c >= 1, "decStrong() called on %p too many times", refs);
if (c == 1) {
/* c == 1说明刚刚removeStrongRef之前，整个系统中只存在一个sp对象引用目标对象，现在的情况就是
系统中没有任何强指针对象来引用目标对象了，此时目标对象就会被删除释放
*/
const_cast<RefBase*>(this)->onLastStrongRef(id);
if ((refs->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK) {
delete this; // mFlags =0 ,条件成立，删除目标对象，这里就会删除前面new出来的BBinder对象
}
}// 如果此时还有其他指向该目标对象的sp指针存在的话，就不会删除目标对象

refs->removeWeakRef(id);
refs->decWeak(id);
/* 删除新建目标对象sp指针时在mWeakRefs链表上增加的两个ref_entry结构体 */
}
/*********************************注释3*********************************/
void removeStrongRef(const void* id)
{
if (!mRetain)// mRetain 初始化成 flase
removeRef(&mStrongRefs, id);
/* 删除mStrongRefs链表中对应id的ref_entry一项 */
/* 也就是取消了该sp对象和目标对象的联系 */
else
addRef(&mStrongRefs, id, -mStrong);
}

void removeRef(ref_entry** refs, const void* id)
{
if (mTrackEnabled) {
AutoMutex _l(mMutex);

ref_entry* ref = *refs;
while (ref != NULL) {
if (ref->id == id) {
*refs = ref->next;
delete ref;
return;
}
refs = &ref->next;
ref = *refs;
}
}
}
/*********************************注释3*********************************/

delete BB_wp_ptr;
这是删除目标对象的一个wp指针，会调用wp的析构函数：
template<typename T>
wp<T>::~wp()
{
if (m_ptr) m_refs->decWeak(this);
}
调用weakref_type类的decWeak()函数，如下：
void RefBase::weakref_type::decWeak(const void* id)
{
weakref_impl* const impl = static_cast<weakref_impl*>(this);
impl->removeWeakRef(id);// 移除weakref_impl对象mWeakRefs链表中对应id的ref_entry结构体
const int32_t c = Android_atomic_dec(&impl->mWeak);// 引用计数减1
LOG_ASSERT(c >= 1, "decWeak called on %p too many times", this);
if (c != 1) return; // c == 1, 说明这是系统中存在的指向目标对象的最后一个wp指针

if ((impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK) {
if (impl->mStrong == INITIAL_STRONG_VALUE)
delete impl->mBase;
// delete impl; 是不是应该加上这么一句，防止用户新建了wp后，不用，马上又删除的情况呢？
/* 当目标对象的最后一个wp被析构时，如果目标对象还没有建立任何一个sp，那么目标对象被删除 */
else {
delete impl;
/* 当目标对象的最后一个wp被析构时，但此时和目标对象相关的sp全部被析构，那么impl->mStrong = 0
在最后一个sp被析构的时候，目标对象也被释放，所以此时只需要释放weakref_impl对象即可
*/
}
} else {
impl->mBase->onLastWeakRef(id);
if ((impl->mFlags&OBJECT_LIFETIME_FOREVER) != OBJECT_LIFETIME_FOREVER) {
delete impl->mBase;
}
}
}

四、wp升级为sp的过程
wp的定义包含了：sp<T> promote() const;
template<typename T>
sp<T> wp<T>::promote() const
{
return sp<T>(m_ptr, m_refs);
}
wp，sp互为友元类，这里promote就是以友元身份调用了sp<Binder>类的构造函数： sp(T* p, weakref_type* refs);
template<typename T>
sp<T>::sp(T* p, weakref_type* refs)
: m_ptr((p && refs->attemptIncStrong(this)) ? p : 0)
{
}
这里如果升级成功，那么将会产生一个sp对象指向目标对象，原来的wp仍然存在。
如果升级不成功，返回NULL
看看关键函数refs->attemptIncStrong(this)

bool RefBase::weakref_type::attemptIncStrong(const void* id)
{
incWeak(id);

weakref_impl* const impl = static_cast<weakref_impl*>(this);

int32_t curCount = impl->mStrong;
LOG_ASSERT(curCount >= 0, "attemptIncStrong called on %p after underflow",
this);
while (curCount > 0 && curCount != INITIAL_STRONG_VALUE) {
if (Android_atomic_cmpxchg(curCount, curCount+1, &impl->mStrong) == 0) {
break;
}
curCount = impl->mStrong;
}// 系统中还有其他sp指向目标对象的情况

if (curCount <= 0 || curCount == INITIAL_STRONG_VALUE) {
bool allow;
if (curCount == INITIAL_STRONG_VALUE) {
// 发现该目标对象还没有一个sp对象与之相关联的话，那么将会新建一个对目标对象的强引用
allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK
|| impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);
} else {
/*
发现系统中原来指向目标对象的sp全部被释放，最后一次sp释放也将目标对象释放了
*/
allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_WEAK
&& impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);
}
if (!allow) {
decWeak(id); // 目标对象已经不存在了，释放前面incWeak(id)产生的ref_entry结构体
return false;
}
curCount = Android_atomic_inc(&impl->mStrong);

if (curCount > 0 && curCount < INITIAL_STRONG_VALUE) {
impl->mBase->onLastStrongRef(id);
}
}
// 走完生成一个sp的必要过程，和前面介绍的是一样
impl->addWeakRef(id);
impl->addStrongRef(id);

if (curCount == INITIAL_STRONG_VALUE) {
Android_atomic_add(-INITIAL_STRONG_VALUE, &impl->mStrong);
impl->mBase->onFirstRef();
}

return true;// 返回true
}

五、总结：
1. weakref_impl对象会随着目标对象的生成而产生，但不一定会随着目标对象的释放而释放。例如：如果目标对象被
1个sp引用，但是同时被2个wp引用，那么在sp被删除的时候，删除了目标对象，但没有删除weakref_impl对象，
只有在最后一个wp释放时，weakref_impl对象会被释放。
2. 一个目标对象被多个sp指针引用，没有wp引用的情况下。释放这些sp的时候，delete会调用sp析构函数，
然后调用RefBase类的成员函数decStrong(), 最后一个sp被释放时，weakref_impl对象数据成员mStrong会
从1减到0(注意mStrong的初始化值为1<<28, 从这个值可以判断出该目标对象有没有被sp指针引用过)，
同时释放目标对象。
3. 一个目标对象被多个wp指针引用，没有sp引用的情况下。delete这些wp的时候，会调用wp的析构函数，该函数会
调用函数decWeak()。当删除最后一个wp的时候，代码中只是删除了目标对象，而没有释放weakref_impl对象，
暂时没发现在哪里释放了它。
4. 一个目标对象既有sp，又有wp来引用。如果sp先被删除光，那么最后一个sp删除的时候会释放掉目标对象，那么此时
mStrong = 0。在后续最后一个wp的释放过程中，在decWeak()函数中就会判断出impl->mStrong !=
INITIAL_STRONG_VALUE,而释放掉剩下的weakref_impl对象了。如果先所以的wp删除光，此时mWeak还等于剩余的sp
的个数，所以此时的释放情况，同第2小点的说明。
5. 从wp定义来看，wp是不能直接操作对象的，必须先升级为sp才行。这个升级的过程是依靠函数promote()来完成的。
升级成功，返回新生成的sp对象指针，升级失败，返回NULL。需要注意的是，如果目标对象之前有过sp指向，但后来
将所有的sp释放完之后，此时目标对象是不存在的，那么此时用户还想将指向该目标对象的wp升级为sp的话，
此时就返回NULL。那么这个时候我们应该delete这些剩下的wp。