在Android native編寫程式碼時，會經常接觸到sp、wp，sp並不是smart pointer的意思，而是strong point；wp就是weak pointer。這兩個概念比較像JAVA中的強弱引用，使用sp和wp可以讓程式設計人員不需要再關係記憶體的釋放問題，防止記憶體洩露。下面先來看它們的類關係圖：

要實現記憶體的自動釋放，sp、wp必須結合RefBase這個類來使用，在Android中，大多數類的最上層基類都是RefBase類。我們舉個簡單的例子，然後順著這個例子來分析RefBase、sp和wp四種不同的應用，並介紹其實現。

1. class A : public RefBase  
2. {  
3. }  

上面定義一個類A，繼承與RefBase，下面我們首先來看RefBases的建構函式：

1. RefBase::RefBase()  
2.     : mRefs(new weakref_impl(this))  
3. {  
4. }  
5.     weakref_impl(RefBase* base)  
6.         : mStrong(INITIAL_STRONG_VALUE)  
7.         , mWeak(0)  
8.         , mBase(base)  
9.         , mFlags(0)  
10.     {  
11.     }  

在RefBase中，首先構造weakref_impl物件，在weakref_impl對mStong和mWeak進行強弱引用計數賦初始值，INITIAL_STRONG_VALUE是0X10000000，這裡不直接賦初始值為0，是方便我們區分，0到底是初始化的值，還是在sp釋放後再變為0，方便做不同的處理。

列舉第一種應用：只有sp指標，沒有wp指標的應用

{

    sp<A> spA(new A);

}

首先來看sp的建構函式：

1. template<typename T>  
2. sp<T>::sp(T* other)  
3.         : m_ptr(other) {  
4.     if (other)  
5.         other->incStrong(this);  
6. }  

首先將實際的A物件的指標賦給m_ptr，然後呼叫A物件的incStrong方法，由上面的類圖關係，我們知道這裡會呼叫RefBase的incStrong方法：

1. void RefBase::incStrong(
   constvoid* id) const
2. {  
3.     weakref_impl* const refs = mRefs;  
4.     refs->incWeak(id);  
5.     refs->addStrongRef(id);  
6.     const int32_t c = android_atomic_inc(&refs->mStrong);  
7.     ALOG_ASSERT(c > 0, "incStrong() called on %p after last strong ref", refs);  
8.     if (c != INITIAL_STRONG_VALUE)  {  
9.         return;  
10.     }  
11.     android_atomic_add(-INITIAL_STRONG_VALUE, &refs->mStrong);  
12.     refs->mBase->onFirstRef();  
13. }  

這裡首先呼叫weakref_impl的incWeak方法來增加弱指標引用數；addStrongRef用於debug版本，正式版中沒有實現；android_atomic_inc是一個原子操作，增加refs->mStrong的強指標引用數，並返回原值；如果是第一次引用改物件，則還會呼叫A物件的onFirstRef方法。首先來看incWeak的實現：

1. void RefBase::weakref_type::incWeak(constvoid* id)  
2. {  
3.     weakref_impl* const impl = static_cast<weakref_impl*>(this);  
4.     impl->addWeakRef(id);  
5.     const int32_t c = android_atomic_inc(&impl->mWeak);  
6.     ALOG_ASSERT(c >= 0, "incWeak called on %p after last weak ref", this);  
7. }  

這裡還是呼叫android_atomic_inc去增加weakref_impl的mWeak計數。經過建構函式，mStong和mWeak的計數都變成了1。當spA物件退出作用域以後，就會呼叫其解構函式來釋放這個物件：

1. template<typename T>  
2. sp<T>::~sp() {  
3.     if (m_ptr)  
4.         m_ptr->decStrong(this);  
5. }  
6. void RefBase::decStrong(constvoid* id) const
7. {  
8.     weakref_impl* const refs = mRefs;  
9.     refs->removeStrongRef(id);  
10.     const int32_t c = android_atomic_dec(&refs->mStrong);  
11.     ALOG_ASSERT(c >= 1, "decStrong() called on %p too many times", refs);  
12.     if (c == 1) {  
13.         refs->mBase->onLastStrongRef(id);  
14.         if ((refs->mFlags&OBJECT_LIFETIME_MASK) == OBJECT_LIFETIME_STRONG) {  
15.             deletethis;  
16.         }  
17.     }  
18.     refs->decWeak(id);  
19. }  

sp物件的解構函式呼叫RefBase的decStrong來減少強弱引用指標計數。weakref_impl的removeStrongRef用於debug版本；呼叫android_atomic_dec減少mStrong計數並返回原值，如果mStrong之前為1了，這是再減少，說明已經沒有其它sp指標引用了，這時候首先呼叫A物件的onLastStrongRef方法，如果Flag設定的是當前物件的生命週期由sp指標決定（這也是default的設定），則釋放掉A物件；然後呼叫weakref_impl的decWeak去減少弱引用指標計數：

1. void RefBase::weakref_type::decWeak(constvoid* id)  
2. {  
3.     weakref_impl* const impl = static_cast<weakref_impl*>(this);  
4.     impl->removeWeakRef(id);  
5.     const int32_t c = android_atomic_dec(&impl->mWeak);  
6.     ALOG_ASSERT(c >= 1, "decWeak called on %p too many times", this);  
7.     if (c != 1) return;  
8.     if ((impl->mFlags&OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_STRONG) {  
9.         if (impl->mStrong == INITIAL_STRONG_VALUE) {  
10.             delete impl->mBase;  
11.         } else {  
12.             delete impl;  
13.         }  
14.     } else {  
15.         impl->mBase->onLastWeakRef(id);  
16.         if ((impl->mFlags&OBJECT_LIFETIME_MASK) == OBJECT_LIFETIME_WEAK) {  
17.             delete impl->mBase;  
18.         }  
19.     }  
20. }  

weakref_impl的removeWeakRef方法也是用於debug版本；然後呼叫android_atomic_dec去減少mWeak計數，如果mWeak之前不等於1，表示還有其它的wp引用，這裡就直接返回。如果這裡的mWeak等於1，說明已經沒有其它sp和wp的引用了，所以這裡要去釋放A物件和weakref_impl物件。

來看判斷是否釋放的邏輯，如果Flag設定當前物件的生命週期由sp指標決定，並且之前沒有初始化過任何sp物件，則直接刪除A物件；如果之前由初始化過sp物件，則刪除weakref_impl本身，A物件會在RefBase的decStrong中被釋放。如果Flag設定當前物件的生命週期由wp指標決定，則首先呼叫A物件的onLastWeakRef方法，然後刪除物件A。在刪除物件A的時候，都會呼叫RefBase的解構函式，我們再來分析RefBase的系統函式：

1. RefBase::~RefBase()  
2. {  
3.     if (mRefs->mStrong == INITIAL_STRONG_VALUE) {  
4.         delete mRefs;  
5.     } else {  
6.         if ((mRefs->mFlags & OBJECT_LIFETIME_MASK) != OBJECT_LIFETIME_STRONG) {  
7.             if (mRefs->mWeak == 0) {  
8.                 delete mRefs;  
9.             }  
10.         }  
11.     }  
12.     const_cast<weakref_impl*&>(mRefs) = NULL;  
13. }  

如果沒有初始化過sp物件，則刪除mRefs物件；如果Flag設定當前物件的生命週期由wp指標決定並且mWeak計數為0，也刪除mRefs物件。

列舉第二種應用：只有wp指標，沒有sp指標的應用

{

    wp<A> wpA(new A);

}

首先來看wp的構造方法：

1. template<typename T>  
2. wp<T>::wp(const sp<T>& other)  
3.     : m_ptr(other.m_ptr)  
4. {  
5.     if (m_ptr) {  
6.         m_refs = m_ptr->createWeak(this);  
7.     }  
8. }  

首先將A物件的指標賦予給m_ptr，可見在sp和wp中都儲存有A物件的實際指標，但wp中並沒有過載"->"，所以wp並不能直接呼叫A物件的方法，並且由前面sp的知識，我們知道，在decStrong的時候，有可能A物件會被釋放，並不會care 是否存在wp的引用。然後呼叫A物件的createWeak方法，實際上是呼叫RefBase的這個方法。注意的是在wp中，m_refs是weakref_type的指標；而在RefBase中，mRefs是weakref_impl的指標，所以在下面的程式碼返回時要注意型別的轉型。

1. RefBase::weakref_type* RefBase::createWeak(constvoid* id) const
2. {  
3.     mRefs->incWeak(id);  
4.     return mRefs;  
5. }  
6. void RefBase::weakref_type::incWeak(constvoid* id)  
7. {  
8.     weakref_impl* const impl = static_cast<weakref_impl*>(this);  
9.     impl->addWeakRef(id);  
10.     const int32_t c = android_atomic_inc(&impl->mWeak);  
11.     ALOG_ASSERT(c >= 0, "incWeak called on %p after last weak ref", this);  
12. }  

這裡只會增加mWeak 計數，這是mStrong等於INITIAL_STRONG_VALUE，mWeak等於1。當wpA退出作用域後，呼叫wp的解構函式：

1. template<typename T>  
2. wp<T>::~wp()  
3. {  
4.     if (m_ptr) m_refs->decWeak(this);  
5. }  

decWeak函式我們上面講過，如果Flag設定當前物件的生命週期由sp指標決定，並且之前沒有初始化過任何sp物件，則直接刪除A物件；並在RefBase的解構函式中取釋放mRefs物件。

列舉第三種應用：既有sp指標，又有wp指標的應用

{

   sp<A> spA(new A)

    wp<A> wpA(spA);

}

從上面它們的建構函式我們知道，這是mStong等於1，mWeak等於2。在spA和wpA退出作用域時，首先呼叫wp的解構函式，再呼叫sp的解構函式。在wp解構函式中，只會減少mWeak計數為1，然後就然後了。再到sp的解構函式中，就和我們前面介紹的第一種應用一樣了。

列舉第四種應用：wp指標如果呼叫物件的方法

前面說過在wp中並沒有過載"->"，所以wp並不能直接呼叫A物件的方法，並且由前面sp的知識，我們知道，在decStrong的時候，有可能A物件會被釋放，所以在wp中想要呼叫A物件的方法，必須獲得sp指標，這是通過wp的promote方法實現的：

1. template<typename T>  
2. sp<T> wp<T>::promote() const
3. {  
4.     sp<T> result;  
5.     if (m_ptr && m_refs->attemptIncStrong(&result)) {  
6.         result.set_pointer(m_ptr);  
7.     }  
8.     return result;  
9. }  

這裡呼叫weakref_type的attemptIncStrong方法去嘗試增加mStrong計數：

1. bool RefBase::weakref_type::attemptIncStrong(constvoid* id)  
2. {  
3.     incWeak(id);  
4.     weakref_impl* const impl = static_cast<weakref_impl*>(this);  
5.     int32_t curCount = impl->mStrong;  
6.     while (curCount > 0 && curCount != INITIAL_STRONG_VALUE) {  
7.         if (android_atomic_cmpxchg(curCount, curCount+1, &impl->mStrong) == 0) {  
8.             break;  
9.         }  
10.         curCount = impl->mStrong;  
11.     }  
12.     if (curCount <= 0 || curCount == INITIAL_STRONG_VALUE) {  
13.         if ((impl->mFlags&OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_STRONG) {  
14.             if (curCount <= 0) {  
15.                 decWeak(id);  
16.                 returnfalse;  
17.             }  
18.             while (curCount > 0) {  
19.                 if (android_atomic_cmpxchg(curCount, curCount + 1,  
20.                         &impl->mStrong) == 0) {  
21.                     break;  
22.                 }  
23.                 curCount = impl->mStrong;  
24.             }  
25.             if (curCount <= 0) {  
26.                 decWeak(id);  
27.                 returnfalse;  
28.             }  
29.         } else {  
30.             if (!impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id)) {  
31.                 decWeak(id);  
32.                 returnfalse;  
33.             }  
34.             curCount = android_atomic_inc(&impl->mStrong);  
35.         }  
36.         if (curCount > 0 && curCount < INITIAL_STRONG_VALUE) {  
37.             impl->mBase->onLastStrongRef(id);  
38.         }  
39.     }  
40.     impl->addStrongRef(id);  
41.     curCount = impl->mStrong;  
42.     while (curCount >= INITIAL_STRONG_VALUE) {  
43.         if (android_atomic_cmpxchg(curCount, curCount-INITIAL_STRONG_VALUE,  
44.                 &impl->mStrong) == 0) {  
45.             break;  
46.         }  
47.         curCount = impl->mStrong;  
48.     }  
49.     returntrue;  
50. }  

首先呼叫incWeak來增加mWeak計數，因為這裡需要獲取sp指標，在sp的建構函式我們知道，會同時增加mWeak和mStrong值。然後根據mStong值分兩種情況討論：

   1. 當前面存在sp的引用，即curCount > 0 && curCount != INITIAL_STRONG_VALUE，這時直接讓mStrong加1。

   2.當前面不存在sp的引用，需要結合Flag去判斷。又分為以下幾種情況：

           一. Flag = OBJECT_LIFETIME_STRONG，並且curCount等於0。說明之前的sp物件已經釋放，由前面的知識我們知道，在釋放sp物件的同時也會釋放物件A，所以這裡呼叫decWeak來釋放前面增加的一次mWeak值並返回false

           二.Flag = OBJECT_LIFETIME_STRONG，並且curCount = INITIAL_STRONG_VALUE，說明前面沒有sp引用，這時我們可以增加mStrong值。

           三.Flag = OBJECT_LIFETIME_WEAK，並且curCount <= 0 || curCount == INITIAL_STRONG_VALUE，則呼叫RefBase的onIncStrongAttempted去嘗試增加mStrong值

當上面任何一種情況增加了mStrong值以後，mSrong的值可能大於INITIAL_STRONG_VALUE，我們需要去修正mStrong，就是通過減去INITIAL_STRONG_VALUE計算。當attemptIncStrong返回true時，promote方法就會呼叫sp的set_pointer方法去設定StrongPointer中的實際A物件的指標。接下來就可以通過sp呼叫相關的方法了。