Android智能指针分析总结

什么是智能指针

C++ 指针需要手动释放，否则会造成内存泄露，但是如果项目工程比较大，一个块内存引用的地方比较多的话，对应这块内存何时释放维护起来就比较困难了，
怎么样才能不需要手动释放，由程序自行处理呢？ Android自己实现了一套智能指针来解决这个问题，Java内存回收机制是采用的是引用计数的方式，Android智能指针也采用类似的方式

智能指针的实现原理

我们来想一下如果需要对每一个对象进行引用计数，那计数应该怎么实现呢？
当然是每个对象都有一个计数器了，Android是这样实现的

Untitled Diagram(2).png

可以看到基类RefBase实现了计数的功能，RefBase中有一个weakref_impl类型mRefs指针， 这个指针是在RefBase构造函数中创建他，这个weakref_impl类型的指针维护了该对象的引用计数，所有要实现引用计数功能的类只需要继承RefBase即可.

    std::atomic<int32_t>    mStrong;
    std::atomic<int32_t>    mWeak;
    RefBase* const          mBase;

mStrong 强引用技术器
mWeak 弱引用计数器
mBase* 指向该对象的指针

计数器已经有了，如何对计数器进行计数呢？
首先我们拿普通对象来看下：

class RefTest : public RefBase{
    ......
}

RefTest* a = new RefTest;
RefTest* b = a;

我们经常碰到这中情况， a和b的指针指向了同一个对象的地址，都在使用这个对象，当a和b都不使用的时候，需要释放掉该对象，否则内存泄露。
计数器应该怎么做呢? 当我们将该对象的地址赋值给指针a的时候，现在需要计数器+1， 当前有一个地方引用了该对象，赋值给指针b的时候，再次+1,表示有两个地方在使用这个对象.
此时该对象是不能被释放的，否则使用他的地方指针会出错. 每当一个地方不在使用的是有计数器-1, 直到计数为0的时候，说明没有地方使用这个对象了，可以释放掉了.

但是仅仅的对象赋值怎么才能使计数器+1呢？
Android是这么实现的， Android实现了两个模板类sp<T> 和 wp<T>来对引用进行计数

sp<RefTest> a = new RefTest;
sp<RefTest> b = a;

当sp中的指针保存对象地址的时候，sp会对RefTest的计数器进行+1，当sp析构的时候，对对象计数器-1，来达到计数的目的.

sp<T> 实现

template<typename T>
class sp {
public:
    inline sp() : m_ptr(0) { }

    sp(T* other);  // NOLINT(implicit)
    sp(const sp<T>& other);
    sp(sp<T>&& other);
    template<typename U> sp(U* other);  // NOLINT(implicit)
    template<typename U> sp(const sp<U>& other);  // NOLINT(implicit)
    template<typename U> sp(sp<U>&& other);  // NOLINT(implicit)

    ~sp();
    // Reset

    void clear();

    ......


private:    
    template<typename Y> friend class sp;
    template<typename Y> friend class wp;
    T* m_ptr;
};

wp<T>实现

template <typename T>
class wp
{
public:
    typedef typename RefBase::weakref_type weakref_type;

    inline wp() : m_ptr(0) { }

    wp(T* other);  // NOLINT(implicit)
    wp(const wp<T>& other);
    explicit wp(const sp<T>& other);
    template<typename U> wp(U* other);  // NOLINT(implicit)
    template<typename U> wp(const sp<U>& other);  // NOLINT(implicit)
    template<typename U> wp(const wp<U>& other);  // NOLINT(implicit)

    ~wp();

    // Assignment

    wp& operator = (T* other);
    wp& operator = (const wp<T>& other);
    wp& operator = (const sp<T>& other);
    ...
private:
    template<typename Y> friend class sp;
    template<typename Y> friend class wp;

    T*              m_ptr;
    weakref_type*   m_refs;
};

从代码中可以看出sp中有T* m_ptr指针，用来保存RefBase子类的对象地址, 当该指针被被赋值的时候，他就调用m_ptr指针指向的RefBase计数+1，当sp析构的时候，调用m_ptr指向的RefBase计数器-1
wp同理

强引用和弱引用

sp<T>和wp<T>分别是强引用和弱引用
使用sp<T> 引用的对象属于强引用，强引用引用对象的时候对对象的计数器 mStrong和mWeak分别+1，当sp<T>强引用销毁的时候，对对象的计数器mStrong和mWeak分别-1
使用wp<T> 引用的对象属于弱引用，弱引用引用对象的时候仅仅对对象的计数器 mWeak +1，当wp<T>弱引用销毁的时候，仅仅对对象的计数器mWeak -1

由此可见，弱引用计数 >= 强引用计数
强引用计数为0的时候，我们就会销毁真正的RefBase对象，所以说仅仅根据wp<RefTest> wa; 是不能访问RefTest对象的，因为此时的RefTest对象很可能已经销毁了，如果想要使用弱引用wa来访问对象，必须调用wa.promote()将弱引用升级成强引用，才可以进行访问。
但是，弱引用升级强引用并不是一定会成功，只有RefBase对象没有被释放的时候才可以.

总结

这里需要注意：
1、智能指针并不是指针，而是一个模板类。
2、强指针增加(减少)强引用计数(mStrong)时，也会相应增加(减少)弱引用计数(mWeak)。
3、弱指针只会增加(减少)弱引用计数(mWeak)。

由2、3点可以看出，mRefs->mWeak总是大于等于mRefs->mStrong。

3、强/弱指针有一些生命周期，当对象被强指针引用时，该对象一定存在。但当对象只被弱指针引用时，根据其生命周期，该对象有可能被释放。