Android sp和wp指针

经常会在android的framework代码中发现sp<xxx>和wp<xxx>这样的指针,平时看的时候都把他当成一个普通的指针封装过掉了，我们现在就来深入研究一下，我们要知道，sp和wp斗是一个模板类，那么我们就先来看看sp类的定义，这样有助于我们理解sp的含义。

Java代码：

1. 
   
2. template <typename T>
   
3. class sp
   
4. {
   
5. public:
   
6. typedef typename RefBase::weakref_type weakref_type;
   
7. inline sp() : m_ptr(0) { }
   
8. sp(T* other);
   
9. sp(const sp<T>& other);
   
10. ~sp();
    
11. ......
    
12. private: 
    
13. // 优化
    
14. 
    
15. sp(T* p, weakref_type* refs);
    
16. 
    
17. T* m_ptr;
    
18. };

复制代码

       可以看到他确实封转了一个原生指针 T* m_ptr. 再看一下其中一个构造函数和析构函数：

Java代码：

1. template<typename T>
   
2. sp<T>::sp(T* other)
   
3. : m_ptr(other)
   
4. {
   
5. if (other) other->incStrong(this);
   
6. }
   
7. 
   
8. template<typename T>
   
9. sp<T>::~sp()
   
10. {
    
11. if (m_ptr) m_ptr->decStrong(this);
    
12. }

复制代码

       我们一看就应该说好奇怪，因为在构造函数中调用了 incStrong()，在析构函数中调用的 decStrong()，显然是管理引用计数的函数，但是 sp类的中并没有定义这两个函数，这两个函数是在 RefBase类中定义的，由此可以得出结论：

       要想使用 sp或者 wp, T必需要继承 RefBase类才行。那么我们来看看效果中给我们呈现的关系。

效果图：


       其中 weakref_type是 RefBase的内嵌类， weakref_impl则是 weakref_type的子类， RefBase的大部分工作都是交由 weakref_impl类来完成，通过 RefBase的成员变量 weakref_impl* const mRefs。查看其中一个 sp的构造函数：

Java代码：

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

复制代码

       可见当一个普通指针变成一个 sp指针后，将会由 RefBase类维护该指针的引用计数，当引用为零时则自动释放该指针指向的内存：

Java代码：

1. void RefBase::decStrong(const void* id) const
   
2. {
   
3. weakref_impl* const refs = mRefs;
   
4. refs->removeStrongRef(id);
   
5. const int32_t c = android_atomic_dec(&refs->mStrong);
   
6. if (c == 1) {
   
7. const_cast<RefBase*>(this)->onLastStrongRef(id);
   
8. if ((refs->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK) {
   
9. delete this; //引用为0，销毁
   
10. }
    
11. }
    
12. refs->removeWeakRef(id);
    
13. refs->decWeak(id);
    
14. }

复制代码

         wp是怎么一回事？

         wp其实是弱指针的意思， wp类型不能直接对类型T进行操作，要想对T进行某种操作，必需把wp升级为sp指针，使用 promote()来实现升级 ：wp weakp= new T();sp t = weakp.promote();wp可能会在弱引用计数不为0的情况下被销毁，执行如下代码：

Java代码：

1. class WPTest : public RefBase {
   
2. public:
   
3. WPTest(){
   
4. LOGD("WPTest constructor");
   
5. }
   
6. virtual ~WPTest() {
   
7. LOGD("WPTest destructor");
   
8. }
   
9. 
   
10. virtual void onFirstRef() {
    
11. LOGD("first weak ptr ref callback");
    
12. }
    
13. 
    
14. virtual void onLastStrongRef(const void* id) {
    
15. LOGD("last strong ptr ref callback");
    
16. }
    
17. 
    
18. virtual void onLastWeakRef(const void* id) {
    
19. LOGD("last weak ptr ref callback");
    
20. }
    
21. };
    
22. 
    
23. 
    
24. int main()
    
25. {
    
26. WPTest *T = new WPTest();
    
27. {
    
28. wp<WPTest> weakp(T);
    
29. 
    
30. {
    
31. LOGD("promote to strong ptr...\n");
    
32. 
    
33. sp<WPTest> strongp = weakp.promote();
    
34. 
    
35. LOGD("strong ptr's lifetime is just about to finish ...\n");
    
36. }
    
37. 
    
38. LOGD("weak ptr's lifetime is just about to finish ...\n");
    
39. }
    
40. 
    
41. LOGD("weak ptr is out of scope.\n");
    
42. 
    
43. return 0;
    
44. }

复制代码

       由此可见虽然 wp的生命周期还没有结束，但是因为升级为 sp后， sp的强引用计数为0，导致 WPTest 被销毁，当强引用为0而弱引用不为0时， WPTest 销毁时，基类 RefBase的 mRefs指向的 weakref_impl类并没有释放，从而保证了弱引用可以继续起作用，这点可以从 RefBase的析构函数中看出来：

Java代码：

1. RefBase::~RefBase()
   
2. {
   
3. // LOGV("Destroying RefBase %p (refs %p)\n", this, mRefs);
   
4. if (mRefs->mWeak == 0) {
   
5. // LOGV("Freeing refs %p of old RefBase %p\n", mRefs, this);
   
6. delete mRefs;
   
7. }
   
8. }

复制代码

        不过也可以改变这一行为，我们修改一下 WPTest的构造函数：

Java代码：

1. WPTest(){
   
2. LOGD("WPTest constructor");
   
3. extendObjectLifetime(OBJECT_LIFETIME_WEAK);
   
4. }

复制代码

       这时的打印结果是：

Java代码：

1. D/sp-wp-sample( 217): WPTest constructor
   
2. D/sp-wp-sample( 217): promote to strong ptr…
   
3. D/sp-wp-sample( 217): first weak ptr ref callbac
   
4. D/sp-wp-sample( 217): strong ptr’s lifetime is j
   
5. D/sp-wp-sample( 217): last strong ptr ref callba
   
6. D/sp-wp-sample( 217): weak ptr’s lifetime is j
   
7. D/sp-wp-sample( 217): last weak ptr ref callback
   
8. D/sp-wp-sample( 217): WPTest destructor
   
9. D/sp-wp-sample( 217): weak ptr is out of scope.
   
10. 
    

复制代码

         可以看出现在只有当强引用和弱引用的计数都为0时， WPTest对象才会被销毁。