Android FrameWork中的SP、RefBase、weakref_impl，Thread类

在阅读Android的Framework处的代码可以发现，无处不在SP给予了我视觉上的冲击，这个是什么？初级的我，看这个当初就基本当成指针来用，熟不知其的内在美，于是在这里和大家一起学习总结SP类的魅力所在。

1 SP这货是个模板类，让我们看下他的结构。

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

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

    ~sp();
    
    // Assignment

    sp& operator = (T* other);
    sp& operator = (const sp<T>& other);
    
    template<typename U> sp& operator = (const sp<U>& other);
    template<typename U> sp& operator = (U* other);
    
    // Reset
    void clear();
    
    // Accessors

    inline  T&      operator* () const  { return *m_ptr; }
    inline  T*      operator-> () const { return m_ptr;  }
    inline  T*      get() const         { return m_ptr; }

    // Operators
        
    COMPARE(==)
    COMPARE(!=)
    COMPARE(>)
    COMPARE(<)
    COMPARE(<=)
    COMPARE(>=)

private:    
    template<typename Y> friend class sp;

    T*              m_ptr;
};

看到了上述的代码结构，瞬间觉得其高大上，作为一个经典的模板类，精懂的人说这个类很好，其实没有过多的去了解他只知道是更好的维护对象。这个SP指针内部有个T* m_ptr成员变量，它是真正指向我们new出来的变量。

我们以sp<A> mA = new A();为例，作为一个模板类的构造函数，调用如下：

template<typename T>
sp<T>::sp(T* other)
    : m_ptr(other)
{
    if (other) other->incStrong(this);
}

果然，new出来的A对象被存入到sp的成员变量之中，这里看到对mA对象构建时，会调用A的一个incStrong，这个是什么？阅读过代码的都知道一个RefBase类，他是比sp类更为常见的类，我们看她的结构可以发现内容都较多，但都是一些很特别的东西，  我们看下面的UML图来分析我们之间构建的A为何要继承与RefBase。

可以看到继承了RefBase，那么A的对象有东西可以玩了，调用RefBase的incStrong函数，接着看他的实现，先来个构造函数过过瘾：

RefBase::RefBase()
    : mRefs(new weakref_impl(this))
{
}

做的东西不多，但是有一个成员变量mRefs，必然他先实现，好吧mRefs被赋值给了一个wekref_impl这个对象，传入的this就是我们的这个new A()对象，好的接着再看看：

    weakref_impl(RefBase* base)
        : mStrong(INITIAL_STRONG_VALUE)
        , mWeak(0)
        , mBase(base)
        , mFlags(0)
    {
    }
 

这里有个mBase，他是一个RefBase类，故按C++的知识，一个从RefBase继承的A类对象被赋值给了mBase，那基类的指针mBase就可以访问类A自带的重载的虚函数了，先留着过会就会用到。

回来我们来看这个刚才other->incStrong()，调用的是基类的incStrong，看他的实现：

void RefBase::incStrong(const void* id) const
{
    weakref_impl* const refs = mRefs;//影子对象的refs
    refs->incWeak(id);
    
    refs->addStrongRef(id);
    const int32_t c = android_atomic_inc(&refs->mStrong);
    ALOG_ASSERT(c > 0, "incStrong() called on %p after last strong ref", refs);
#if PRINT_REFS
    ALOGD("incStrong of %p from %p: cnt=%d\n", this, id, c);
#endif
    if (c != INITIAL_STRONG_VALUE)  {
        return;
    }

    android_atomic_add(-INITIAL_STRONG_VALUE, &refs->mStrong);
    refs->mBase->onFirstRef();//mBase维护着继承类实际对象this指针
}

这里是增加了对这个指针的引用次数，最重要的一点是关注最后一行代码，在我们写自己类的时候一般都喜欢重载该函数，在这里面对类对象进行必要的初始化。

refs为mRefs，就是我们类A的对象的一个继承成员weakref_impl,该对象有个内部成员mBase,通过上面的分析可知mBase就是指向类A对象的指针，故当访问虚函数时，实际调用的是派生类的重载函数，故最终首次建立一个sp<A> mA 时，就也是所谓的第一次引用吧。

 

2.学一学Android Native的Thread类

上面介绍了很多的类，在onFirstRef里面可以经常会遇到一个run函数，这是启动一个新线程的方法，那就是你的类A 继承了thread类，从上一UML图可以看到，thread有几个核心的函数，最重要的就是一个run函数。来看她的部分代码：

status_t Thread::run(const char* name, int32_t priority, size_t stack)
{
    Mutex::Autolock _l(mLock);

    if (mRunning) {
        // thread already started
        return INVALID_OPERATION;
    }

    // reset status and exitPending to their default value, so we can
    // try again after an error happened (either below, or in readyToRun())
    mStatus = NO_ERROR;
    mExitPending = false;
    mThread = thread_id_t(-1);
    
    // hold a strong reference on ourself
    mHoldSelf = this;

    mRunning = true;

    bool res;
    if (mCanCallJava) {
        res = createThreadEtc(_threadLoop,
                this, name, priority, stack, &mThread);//启动_threadLoop线程
    } else {
        res = androidCreateRawThreadEtc(_threadLoop,
                this, name, priority, stack, &mThread);
    }
    
    if (res == false) {
        mStatus = UNKNOWN_ERROR;   // something happened!
        mRunning = false;
        mThread = thread_id_t(-1);
        mHoldSelf.clear();  // "this" may have gone away after this.

        return UNKNOWN_ERROR;
    }
    
    // Do not refer to mStatus here: The thread is already running (may, in fact
    // already have exited with a valid mStatus result). The NO_ERROR indication
    // here merely indicates successfully starting the thread and does not
    // imply successful termination/execution.
    return NO_ERROR;

    // Exiting scope of mLock is a memory barrier and allows new thread to run
}

源码上深入的话会比较复杂，但是一点可以肯定的是调用的线程函数是_thread_Loop,看看他的实现：

int Thread::_threadLoop(void* user)
{
    Thread* const self = static_cast<Thread*>(user);//派生类对象转为基类指针
do {
        bool result;
        if (first) {
            first = false;
            self->mStatus = self->readyToRun();//直接调用继承类的readyToRun
            result = (self->mStatus == NO_ERROR);
......
           else
            result = self->threadLoop();
        }
}

这里的self是什么，实际是我们新建的一个对象，那么首次就是调用类A的操作函数readyToRun()，随后一般是调用threadLoop进入线程的循环，线程的退出主要由threadLoop函数的返回结果来决定。

 

3. 好了，下面再来看看这个这几个比较常见的过程，会和C++的多态符合重载有紧密的关系。

比如mA->fun(),一眼看去感觉和普通的指针调用没有区别，但你是否知道mA只是一个sp类的对象，那么这个mA->的操作符是什么？那就是所谓的符合重载，来看sp的几个运算符的重载函数：

   inline  T&      operator* () const  { return *m_ptr; }
    inline  T*      operator-> () const { return m_ptr;  }
    inline  T*      get() const         { return m_ptr; }

很好，可以看到他的实现，不需要输入参数，返回一个m_ptr，m_ptr是什么，前面说过他是我们new A()出来的一个对象，那么调用的就是类A所属的成员函数.类似的还有：

template<typename T>
sp<T>& sp<T>::operator = (T* other)
{
    if (other) other->incStrong(this);
    if (m_ptr) m_ptr->decStrong(this);
    m_ptr = other;
    return *this;
}

template<typename T> template<typename U>
sp<T>& sp<T>::operator = (const sp<U>& other)
{
    T* otherPtr(other.m_ptr);
    if (otherPtr) otherPtr->incStrong(this);
    if (m_ptr) m_ptr->decStrong(this);
    m_ptr = otherPtr;
    return *this;
}

分别是对指针与引用的赋值操作。

 

上述的Android Framework里面会经常遇到这些细节性的问题，了解这些基本类往往可以做到事半功倍，阅读代码更加心领神会！