Android架構分析之Android智慧指標（二）
作者：劉昊昱
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。