首页 > 代码库 > Android架构分析之Android智能指针(二)

Android架构分析之Android智能指针(二)

作者:刘昊昱 

博客:http://blog.csdn.net/liuhaoyutz

Android版本:4.4.2

 

在上一篇文章中,我们分析了Android智能指针中的强指针sp,本文我们来分析弱指针wp。为什么需要弱指针wp呢?我们来考虑下面一种场景:有两个类CParent和CChild,CParent类中有一个智能指针指向CChild对象,CChild类中有一个智能指针指向CParent对象

class CParent :public LightRefBase<CParent>
{
       ……
       sp<CChild> spc;
       ……
}
 
class CChild :public LightRefBase<CChild>
{
       ……
       sp<CParent> spp
       ……
}


分别创建CParent类对象parent和CChild对象child,让parent.spc指向child,让child.spp指向parent。这样,parent和child的引用计数器的值都是1,当要释放parent和child时,因为它们的引用计数器都是1,并且系统一次只能析构一个对象,这就造成一种死锁,无法析构parent和child对象中的任何一个。这样,也同样造成内存泄漏的问题。为此,Android引入了弱指针wp,定义在frameworks/rs/cpp/util/RefBase.h文件中,我们先来看wp的定义:

197template<typename T>
198class wp
199{
200public:
201    typedef typename RefBase::weakref_typeweakref_type;
202
203    inline wp() : m_ptr(0) { }
204
205    wp(T* other);
206    wp(const wp<T>& other);
207    wp(const sp<T>& other);
208    template<typename U> wp(U* other);
209    template<typename U> wp(constsp<U>& other);
210    template<typename U> wp(constwp<U>& other);
211
212    ~wp();
213
214    // Assignment
215
216    wp& operator = (T* other);
217    wp& operator = (const wp<T>&other);
218    wp& operator = (const sp<T>&other);
219
220    template<typename U> wp& operator= (U* other);
221    template<typename U> wp& operator= (const wp<U>& other);
222    template<typename U> wp& operator= (const sp<U>& other);
223
224    void set_object_and_refs(T* other,weakref_type* refs);
225
226    // promotion to sp
227
228    sp<T> promote() const;
229
230    // Reset
231
232    void clear();
233
234    // Accessors
235
236    inline weakref_type* get_refs() const { return m_refs; }
237
238    inline T* unsafe_get() const { return m_ptr; }
239
240    // Operators
241
242    COMPARE_WEAK(==)
243    COMPARE_WEAK(!=)
244    COMPARE_WEAK(>)
245    COMPARE_WEAK(<)
246    COMPARE_WEAK(<=)
247    COMPARE_WEAK(>=)
248
249    inline bool operator == (constwp<T>& o) const {
250        return (m_ptr == o.m_ptr) &&(m_refs == o.m_refs);
251    }
252    template<typename U>
253    inline bool operator == (constwp<U>& o) const {
254        return m_ptr == o.m_ptr;
255    }
256
257    inline bool operator > (constwp<T>& o) const {
258        return (m_ptr == o.m_ptr) ? (m_refs> o.m_refs) : (m_ptr > o.m_ptr);
259    }
260    template<typename U>
261    inline bool operator > (constwp<U>& o) const {
262        return (m_ptr == o.m_ptr) ? (m_refs> o.m_refs) : (m_ptr > o.m_ptr);
263    }
264
265    inline bool operator < (constwp<T>& o) const {
266        return (m_ptr == o.m_ptr) ? (m_refs< o.m_refs) : (m_ptr < o.m_ptr);
267    }
268    template<typename U>
269    inline bool operator < (constwp<U>& o) const {
270        return (m_ptr == o.m_ptr) ? (m_refs< o.m_refs) : (m_ptr < o.m_ptr);
271    }
272                         inline bool operator!= (const wp<T>& o) const { return m_refs != o.m_refs; }
273    template<typename U> inline booloperator != (const wp<U>& o) const { return !operator == (o); }
274                         inline bool operator<= (const wp<T>& o) const { return !operator > (o); }
275    template<typename U> inline booloperator <= (const wp<U>& o) const { return !operator > (o); }
276                         inline bool operator>= (const wp<T>& o) const { return !operator < (o); }
277    template<typename U> inline booloperator >= (const wp<U>& o) const { return !operator < (o); }
278
279private:
280    template<typename Y> friend class sp;
281    template<typename Y> friend class wp;
282
283    T*              m_ptr;
284    weakref_type*   m_refs;
285};


可以看到,弱指针wp与强指针sp基本内容是类似的,但是又有如下区别:

1、wp多了一个weakref_type类型的指针变量m_refs。

2、wp有一个promote函数,用于将wp升级为sp。

3、还有一点重要区别,后面我们会看到,wp目标对象的父类是RefBase而不是LightRefBase。

Android规定:

1、当一个对象强引用计数为0时,不论弱引用计数是否为0,都可以释放该对象。

2、我们不能通过弱指针wp直接操作引用对象,如果要操作,必须先将wp通过promote函数升级为sp才行。

在frameworks/rs/cpp/util/RefBase.h文件中,RefBase类定义如下:

65class RefBase
 66{
 67public:
 68            void            incStrong(const void* id) const;
 69            void            decStrong(const void* id) const;
 70
 71            void            forceIncStrong(const void* id)const;
 72
 73            //! DEBUGGING ONLY: Get currentstrong ref count.
 74            int32_t         getStrongCount() const;
 75
 76    class weakref_type
 77    {
 78    public:
 79        RefBase*            refBase() const;
 80
 81        void                incWeak(const void* id);
 82        void                decWeak(const void* id);
 83
 84        // acquires a strong reference if thereis already one.
 85        bool                attemptIncStrong(const void*id);
 86
 87        // acquires a weak reference if thereis already one.
 88        // This is not always safe. seeProcessState.cpp and BpBinder.cpp
 89        // for proper use.
 90        bool                attemptIncWeak(const void* id);
 91
 92        //! DEBUGGING ONLY: Get current weakref count.
 93        int32_t             getWeakCount() const;
 94
 95        //! DEBUGGING ONLY: Print referencesheld on object.
 96        void                printRefs() const;
 97
 98        //! DEBUGGING ONLY: Enable tracking forthis object.
 99        // enable -- enable/disable tracking
100        // retain -- whentracking is enable, if true, then we save a stack trace
101        //           for each reference and dereference;when retain == false, we
102        //           match up references and dereferencesand keep only the
103        //           outstanding ones.
104
105        void                trackMe(bool enable, boolretain);
106    };
107
108            weakref_type*   createWeak(const void* id) const;
109
110            weakref_type*   getWeakRefs() const;
111
112            //! DEBUGGING ONLY:Print references held on object.
113    inline  void           printRefs() const {getWeakRefs()->printRefs(); }
114
115            //! DEBUGGING ONLY:Enable tracking of object.
116    inline  void            trackMe(bool enable, bool retain)
117    {
118       getWeakRefs()->trackMe(enable, retain);
119    }
120
121    typedef RefBase basetype;
122
123protected:
124                           RefBase();
125    virtual                 ~RefBase();
126
127    //! Flags forextendObjectLifetime()
128    enum {
129       OBJECT_LIFETIME_STRONG  = 0x0000,
130        OBJECT_LIFETIME_WEAK    = 0x0001,
131       OBJECT_LIFETIME_MASK    = 0x0001
132    };
133
134            void            extendObjectLifetime(int32_t mode);
135
136    //! Flags foronIncStrongAttempted()
137    enum {
138        FIRST_INC_STRONG =0x0001
139    };
140
141    virtual void            onFirstRef();
142    virtual void            onLastStrongRef(const void* id);
143    virtual bool            onIncStrongAttempted(uint32_tflags, const void* id);
144    virtual void            onLastWeakRef(const void* id);
145
146private:
147    friend classReferenceMover;
148    static voidmoveReferences(void* d, void const* s, size_t n,
149            constReferenceConverterBase& caster);
150
151private:
152    friend class weakref_type;
153    class weakref_impl;
154
155                           RefBase(const RefBase& o);
156            RefBase&        operator=(const RefBase& o);
157
158        weakref_impl* constmRefs;
159};


与LightRefBase给sp指向的对象提供引用计数器类似,RefBase用于给被wp指向的对象提供引用计数器功能。LightRefBase的引用计数器具体实现为一个整数LightRefBase.mCount,但是我们在RefBase类中并没有一个对应的整数作为引用计数器,那么RefBase的引用计数器是谁呢?实际上是RefBase.mRefs,它是weakref_impl类的指针。weakref_impl类中有两个成员变量mStrong和mWeak,即强引用计数和弱引用计数。RefBase.mRefs是在RefBase的构造函数中进行初始化的:

579RefBase::RefBase()
580    : mRefs(newweakref_impl(this))
581{
582}


580行,new一个weakref_impl对象,赋值给RefBase.mRefs。

RefBase::weakref_impl定义在system/core/libutils/RefBase.cpp文件中,如下所示:

60class RefBase::weakref_impl : public RefBase::weakref_type
 61{
 62public:
 63    volatile int32_t    mStrong;
 64    volatile int32_t    mWeak;
 65    RefBase* const      mBase;
 66    volatile int32_t    mFlags;
 67
 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
    ……
    ……
313#endif
314};


weakref_impl类的定义内容虽然很长,但是从87行到最后都是用于debug调试,可以忽略。78-85行定义的函数都没有具体实现,所以也可以忽略。

70-76行,构造函数中对mStrong、mWeak、mBase、mFlags进行初始化。mStrong被初始化为INITIAL_STRONG_VALUE,该宏定义在system/core/libutils/RefBase.cpp文件中:

56#define INITIAL_STRONG_VALUE (1<<28)

看起来weakref_impl类只是提供了mStrong、mWeak、mBase、mFlags四个成员变量,并进行初始化,没有实现什么功能,但是要注意weakref_impl继承自RefBase::weakref_type类。

和分析sp时一样,我们考虑要让wp指向一个对象(该对象的弱引用计数应该加1),可能通过wp的构造函数,也可能通过重载的“=”赋值运算符。我们来看wp的构造函数,如下:

295template<typename T>
296wp<T>::wp(T* other)
297    : m_ptr(other)
298{
299    if (other) m_refs =other->createWeak(this);
300}


再来看重载的赋值运算符,如下:

350template<typename T>
351wp<T>& wp<T>::operator = (T* other)
352{
353    weakref_type* newRefs =
354        other ?other->createWeak(this) : 0;
355    if (m_ptr)m_refs->decWeak(this);
356    m_ptr = other;
357    m_refs = newRefs;
358    return *this;
359}


注意,这两个函数都没有直接增加对象other的弱引用计数(即RefBase.mRefs->mWeak),实际上,是通过调用other->createWeak(this)增加other的弱引用计数。该函数定义在system/core/libutils/RefBase.cpp文件中:

568RefBase::weakref_type* RefBase::createWeak(const void* id) const
569{
570    mRefs->incWeak(id);
571    return mRefs;
572}


570行调用mRefs即weakref_impl类的inWeak函数,给弱引用计数加1。

571行,返回RefBase.mRefs,注意它是weakref_impl类型指针。而在wp构造函数和重载的赋值运算符中,createWeak函数的返回值赋值给wp.m_refs。这样,通过wp.m_refs和other.mRefs都可以访问到引用计数器weakref_impl。

该函数定义如下:

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}


390行,addWeakRef函数是空函数,没有实现。

391行,调用android_atomic_inc,给弱引用计数mWeak加1。

分析到这里,我们就清楚怎样给弱引用计数加1的了。

 

再来看wp的析构函数:

344template<typename T>
345wp<T>::~wp()
346{
347    if (m_ptr)m_refs->decWeak(this);
348}


其调用的是m_refs即weakref_type.decWeak函数,该函数定义如下:

396void RefBase::weakref_type::decWeak(const void* id)
397{
398    weakref_impl* const impl =static_cast<weakref_impl*>(this);
399    impl->removeWeakRef(id);
400    const int32_t c =android_atomic_dec(&impl->mWeak);
401    ALOG_ASSERT(c >= 1,"decWeak called on %p too many times", this);
402    if (c != 1) return;
403
404    if((impl->mFlags&OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_STRONG) {
405        // This is the regularlifetime case. The object is destroyed
406        // when the last strongreference goes away. Since weakref_impl
407        // outlive the object,it is not destroyed in the dtor, and
408        // we'll have to do ithere.
409        if (impl->mStrong ==INITIAL_STRONG_VALUE) {
410            // Special case: wenever had a strong reference, so we need to
411            // destroy theobject now.
412            deleteimpl->mBase;
413        } else {
414            // ALOGV("Freeingrefs %p of old RefBase %p\n", this, impl->mBase);
415            delete impl;
416        }
417    } else {
418        // less common case:lifetime is OBJECT_LIFETIME_{WEAK|FOREVER}
419       impl->mBase->onLastWeakRef(id);
420        if ((impl->mFlags&OBJECT_LIFETIME_MASK)== OBJECT_LIFETIME_WEAK) {
421            // this is theOBJECT_LIFETIME_WEAK case. The last weak-reference
422            // is gone, we candestroy the object.
423            deleteimpl->mBase;
424        }
425    }
426}


400行,调用android_atomic_dec减小弱引用计数。

402行,如果弱引用计数不为0,则直接退出。

404-425行,根据是否是强引用,分别进行释放工作。

 

如果用一个sp指针指向一个继承了RefBase的类对象时,会发生什么呢?从上一篇分析sp的文章中,我们知道此时会调用RefBase.incStrong函数,该函数定义如下:

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 %pfrom %p: cnt=%d\n", this, id, c);
328#endif
329    if (c !=INITIAL_STRONG_VALUE)  {
330        return;
331    }
332
333   android_atomic_add(-INITIAL_STRONG_VALUE, &refs->mStrong);
334   refs->mBase->onFirstRef();
335}


320行,mRefs就是该RefBase对应的计数器。

321行,增加弱引用计数。

323行,addStrongRef是一个空函数。

324行,调用android_atomic_inc增加强引用计数,即weakref_impl.mStrong。

329-331行,如果不是第一次被强指针引用,直接返回。

333行,如果是第一次被强指针引用,mStrong的值还需要减去INITIAL_STRONG_VALUE,其值才为1。

334行,refs->mBase->onFirstRef()是一个空函数。

强引用被释放时,会调用decStrong函数:

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 %pfrom %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) {
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}


339行,mRefs就是该RefBase对应的计数器。

340行,removeStrongRef函数是一个空函数。

341行,将强引用计数mStrong减1。

346行,当强引用全部被释放后,释放该对象。

352行,调用decWeak函数给弱引用计数减1。