如果一个类的对象支持使用弱指针，那么这个类就必须要从RefBase类继承下来，因为RefBase类提供了弱引用计数器。在前面的3.2.1小节中，我们已经分析过RefBase类的实现了，因此，在本节中，我们只分析弱指针类wp的实现。 wp类的定义如下所示。 **frameworks/base/include/utils/RefBase.h** ~~~ template <typename T> class wp { public: typedef typename RefBase::weakref_type weakref_type; inline wp() : m_ptr(0) { } wp(T* other); wp(const wp<T>& other); wp(const sp<T>& other); template<typename U> wp(U* other); template<typename U> wp(const sp<U>& other); template<typename U> wp(const wp<U>& other); ~wp(); // Assignment wp& operator = (T* other); wp& operator = (const wp<T>& other); wp& operator = (const sp<T>& other); template<typename U> wp& operator = (U* other); template<typename U> wp& operator = (const wp<U>& other); template<typename U> wp& operator = (const sp<U>& other); void set_object_and_refs(T* other， weakref_type* refs); // promotion to sp sp<T> promote() const; // Reset void clear(); // Accessors inline weakref_type* get_refs() const { return m_refs; } inline T* unsafe_get() const { return m_ptr; } // Operators COMPARE_WEAK(==) COMPARE_WEAK(!=) COMPARE_WEAK(>) COMPARE_WEAK(<) COMPARE_WEAK(<=) COMPARE_WEAK(>=) inline bool operator == (const wp<T>& o) const { return (m_ptr == o.m_ptr) && (m_refs == o.m_refs); } template<typename U> inline bool operator == (const wp<U>& o) const { return m_ptr == o.m_ptr; } inline bool operator > (const wp<T>& o) const { return (m_ptr == o.m_ptr) ? (m_refs > o.m_refs) : (m_ptr > o.m_ptr); } template<typename U> inline bool operator > (const wp<U>& o) const { return (m_ptr == o.m_ptr) ? (m_refs > o.m_refs) : (m_ptr > o.m_ptr); } inline bool operator < (const wp<T>& o) const { return (m_ptr == o.m_ptr) ? (m_refs < o.m_refs) : (m_ptr < o.m_ptr); } template<typename U> inline bool operator < (const wp<U>& o) const { return (m_ptr == o.m_ptr) ? (m_refs < o.m_refs) : (m_ptr < o.m_ptr); } inline bool operator != (const wp<T>& o) const { return m_refs != o.m_refs; } template<typename U> inline bool operator != (const wp<U>& o) const { return !operator == (o); } inline bool operator <= (const wp<T>& o) const { return !operator > (o); } template<typename U> inline bool operator <= (const wp<U>& o) const { return !operator > (o); } inline bool operator >= (const wp<T>& o) const { return !operator < (o); } template<typename U> inline bool operator >= (const wp<U>& o) const { return !operator < (o); } private: template<typename Y> friend class sp; template<typename Y> friend class wp; T* m_ptr; weakref_type* m_refs; }; ~~~ wp类是一个模板类，其中，模板参数T表示对象的实际类型，它必须是从RefBase类继承下来的。与强指针类sp类似，弱指针类wp也有一个成员变量m_ptr，用来指向它所引用的对象，但是弱指针类wp还使用另外一个类型为weakref_type*的成员变量m_refs，用来维护对象的弱引用计数。 弱指针与强指针有一个很大的区别，就是弱指针不可以直接操作它所引用的对象，因为它所引用的对象可能是不受弱引用计数控制的，即它所引用的对象可能是一个无效的对象。因此，如果需要操作一个弱指针所引用的对象，那么就需要将这个弱指针升级为强指针，这是通过调用它的成员函数promote来实现的。如果升级成功，就说明该弱指针所引用的对象还没有被销毁，可以正常使用。 wp类的实现比较复杂，但是只要掌握了它的构造函数和析构函数的实现，以及它是如何将一个弱指针升级为强指针的，就可以理解它的实现原理了。因此，在接下来的内容中，我们首先分析wp类的构造函数和析构函数的实现，然后再分析它的成员函数promote的实现。 wp类的构造函数的实现如下所示。 **frameworks/base/include/utils/RefBase.h** ~~~ template<typename T> wp<T>::wp(T* other) : m_ptr(other) { if (other) m_refs = other->createWeak(this); } ~~~ > 注意：模板参数T是一个继承了RefBase类的子类，因此，第5行实际上是调用了RefBase类的成员函数createWeak来增加对象的弱引用计数，如下所示。 **frameworks/base/libs/utils/RefBase.cpp** ~~~ RefBase::weakref_type* RefBase::createWeak(const void* id) const { mRefs->incWeak(id); return mRefs; } ~~~ RefBase类的成员变量mRefs指向的是一个weakref_impl对象。在前面的3.2.1小节中，我们已经介绍过它的成员函数incWeak的实现，它主要就是增加实际引用对象的弱引用计数。RefBase类的成员函数createWeak最后将它的成员变量mRefs所指向的一个weakref_impl对象返回给调用者。 wp类的析构函数的实现如下所示。 **frameworks/base/include/utils/RefBase.h** ~~~ template<typename T> wp<T>::~wp() { if (m_ptr) m_refs->decWeak(this); } ~~~ 弱指针在析构时，会调用它的成员变量m_refs的成员函数decWeak来减少对象的弱引用计数。从wp类的构造函数的实现可以知道，wp类的成员变量m_refs指向的是一个weakref_impl对象，因此，第4行实际上是调用了weakref_impl类的成员函数decWeak来减少对象的弱引用计数。在前面的3.2.1小节中，我们已经分析过weakref_impl类的成员函数decWeak的实现，它主要就是将对象的弱引用计数值减少1。 介绍完wp类的构造函数和析构函数的实现之后，我们就来重点分析wp类的成员函数promote的实现。因为所有的弱指针都要通过调用这个成员函数来成功升级为强指针之后，才能操作它所引用的对象。wp类是如何使得一个弱指针不能直接操作它所引用的对象的呢?秘密就在于wp类没有重载*和->操作符号，因此，我们就不能直接操作它所引用的对象。回到正题，wp类的成员函数promote的实现如下所示。 **frameworks/base/include/utils/RefBase.h** ~~~ template<typename T> sp<T> wp<T>::promote() const { return sp<T>(m_ptr， m_refs); } ~~~ 弱指针升级为强指针的方式是通过其内部的成员变量m_ptr和m_refs来创建一个强指针。 **frameworks/base/include/utils/RefBase.h** ~~~ template<typename T> sp<T>::sp(T* p， weakref_type* refs) : m_ptr((p && refs->attemptIncStrong(this)) ? p : 0) { } ~~~ 参数p指向对象的地址，而参数refs指向该对象内部的一个弱引用计数器对象。只有在对象地址不为NULL的情况下，才会调用它内部的弱引用计数器对象的成员函数attemptIncStrong来试图增加该对象的强引用计数。如果能够成功增加对象的强引用计数，那么就可以成功地把一个弱指针升级为一个强指针了。参数refs是一个类型为weakref_type的指针，因此，接下来就会调用weakref_type类的成员函数attemptIncStrong，它的实现如下所示。 **frameworks/base/libs/utils/RefBase.cpp** ~~~ 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; } if (curCount <= 0 || curCount == INITIAL_STRONG_VALUE) { bool allow; if (curCount == INITIAL_STRONG_VALUE) { // Attempting to acquire first strong reference... this is allowed // if the object does NOT have a longer lifetime (meaning the // implementation doesn’t need to see this)， or if the implementation // allows it to happen. allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK || impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG， id); } else { // Attempting to revive the object... this is allowed // if the object DOES have a longer lifetime (so we can safely // call the object with only a weak ref) and the implementation // allows it to happen. allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_WEAK && impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG， id); } if (!allow) { decWeak(id); return false; } curCount = android_atomic_inc(&impl->mStrong); // If the strong reference count has already been incremented by // someone else， the implementor of onIncStrongAttempted() is holding // an unneeded reference. So call onLastStrongRef() here to remove it. // (No， this is not pretty.) Note that we MUST NOT do this if we // are in fact acquiring the first reference. if (curCount > 0 && curCount < INITIAL_STRONG_VALUE) { impl->mBase->onLastStrongRef(id); } } impl->addWeakRef(id); impl->addStrongRef(id); #if PRINT_REFS LOGD("attemptIncStrong of %p from %p: cnt=%d\n"， this， id， curCount); #endif if (curCount == INITIAL_STRONG_VALUE) { android_atomic_add(-INITIAL_STRONG_VALUE， &impl->mStrong); impl->mBase->onFirstRef(); } return true; } ~~~ weakref_type类的成员函数attemptIncStrong试图增加目标对象的强引用计数，但是有可能会增加失败，因为目标对象可能已经被释放了，或者该目标对象不允许使用强指针引用它。 在前面的3.2.1小节中提到，在增加对象的强引用计数时，同时也会增加该对象的弱引用计数，因此，函数第3行首先调用成员函数incWeak来增加对象的弱引用计数。如果后面增加对象的强引用计数失败，则会调用成员函数decWeak来减少对象的弱引用计数。前面提到，wp类的成员变量m_refs实际上指向的是一个weakref_impl对象，因此，第5行可以安全地将this指针转换为一个weakref_impl指针，保存在变量impl中。 一个弱指针所引用的对象可能处于两种状态。第一种状态是该对象同时也正在被其他强指针所引用，即它的强引用计数值大于0，并且不等于INITIAL_STRONG_VALUE;第二种状态是该对象没有被任何强指针引用，即它的强引用计数值小于等于0，或者等于INITIAL_STRONG_VALUE。接下来，我们就根据这两种情况来分析一个弱指针是如何升级为一个强指针的。 第一种情况比较简单，因为这时候对象是一定存在的，因此，我们就可以安全地将这个弱指针升级为强指针。函数第10行到第15行代码处理的正是第一种情况，它将对象的强引用计数值增加1。在增加对象的强引用计数时，要保证原子性，因为其他地方也有可能正在对该对象的强引用计数进行操作。前面我们一般都是直接调用android_atomic_inc函数来保证加1操作的原子性的，但是第11行调用了函数android_atomic_cmpxchg来实现。函数android_atomic_cmpxchg是一个与CPU体系结构相关的函数，在某些提供了特殊指令的体系结构中，函数android_atomic_cmpxchg执行原子性的加1操作效率会比函数android_atomic_inc高一些。 函数android_atomic_cmpxchg的原型如下所示。 **system/core/include/cutils/atomic.h** ~~~ int android_atomic_release_cas(int32_t oldvalue， int32_t newvalue， volatile int32_t* addr); #define android_atomic_cmpxchg android_atomic_release_cas ~~~ 它只是一个宏定义，实际上指向的是函数android_atomic_release_cas。函数android_atomic_release_cas的工作原理是这样的:如果它发现地址addr的内容等于参数oldvalue的值，那么它就会将地址addr的内容修改为newvalue，然后给调用者返回0，表示修改地址addr的内容成功;否则，就什么也不做， 然后给调用者返回1。 回到weakref_type类的成员函数attemptIncStrong中，第11行在调用android_atomic_cmpxchg函数时，将参数oldvalue的值设置为curCount，而将参数newvalue的值设置为curCount + 1。变量curCount保存的是对象的强引用计数，因此，第11行调用android_atomic_cmpxchg函数的目的是增加对象的强引用计数。在什么情况下，函数android_atomic_release_cas会不能成功地增加对象的强引用计数呢?在调用函数android_atomic_cmpxchg之前，对象的强引用计数保存在变量curCount中，在这种情况下，在调用函数android_atomic_cmpxchg时，有可能其他线程已经修改了对象的强引用计数。因此，就会导致函数android_atomic_cmpxchg不能成功地增加对象的强引用计数。如果出现这种情况，第10行到第15行的while循环就必须重新执行增加对象的强引用计数的操作。 在第二种情况下，第17行的if语句会为true，这时候情况就比较复杂了，因为此时对象可能存在，也可能不存在，要进一步进行判断。 如果对象的强引用计数值等于INITIAL_STRONG_VALUE，即第19行的if语句为true，那么就说明这个对象从来没有被强指针引用过。因此，第24行和第25行就根据对象的生命周期控制方式或者对象的实现来判断是否允许将一个引用了它的弱指针升级为强指针。如果对象的生命周期只受强引用计数影响，那么就可以成功地将该弱指针升级为强指针。这一点比较容易理解，因为如果对象的生命周期只受强引用计数影响，而此时该对象又没有被强指针引用过，那么它就必然不会被释放；如果对象的生命周期受弱引用计数影响，即第24行的表达式(impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK为false，那么就说明对象现在肯定是存在的，因为现在正有一个弱指针在引用它。但是，这种情况需要进一步调用对象的成员函数onIncStrongAttempted来确认对象是否允许强指针引用它。如果对象的成员函数onIncStrongAttempted的返回值为true，就说明允许使用强指针来引用它，因此，这种情况也可以成功地将该弱指针升级为强指针。RefBase类的成员函数在参数flags为FIRST_INC_STRONG的情况下，是允许将一个指向只受弱引用计数影响生命周期的对象的弱指针升级为一个强指针的，它的实现如下所示。 **frameworks/base/libs/utils/RefBase.cpp** ~~~ bool RefBase::onIncStrongAttempted(uint32_t flags， const void* id) { return (flags&FIRST_INC_STRONG) ? true : false; } ~~~ 如果对象的强引用计数值小于等于0，那么就会执行第31行和第32行代码。这时候说明对象之前被强指针引用过，因此，就必须要保证对象的生命周期受到弱引用计数的影响;否则，对象就已经被释放了。当对象的生命周期控制标志值的OBJECT_LIFETIME_WEAK位不等于0时，就说明对象的生命周期受到弱引用计数的影响，但是这时候还不能直接将该弱指针升级为强指针，因为对象可能不希望它被强指针引用。因此，就需要调用对象的成员函数onIncStrongAttempted来进一步确认。如果对象的成员函数onIncStrongAttempted的返回值为true，就说明允许将该弱指针升级为强指针。 在第二种情况下，如果最终得到的变量allow的值为false，那么就说明弱指针升级为强指针失败，于是函数第36行就直接返回false给调用者了。在返回之前，第35行会调用成员函数decWeak来减少对象的弱引用计数，因为函数在开始的地方调用了成员函数incWeak来增加对象的弱引用计数。另外，如果最终得到的变量allow的值为true，那么就说明弱指针可以升级为强指针，因此，第38行就会增加对象的强引用计数。 至此，弱指针升级为强指针的过程就介绍完了，它是弱指针实现原理中最具有挑战性的一个环节。 Android系统提供的强指针和弱指针的实现比较复杂，接下来，我们再通过一个实例来说明它们的使用方法，以便加深对它们的理解。