Android的轻量级指针原理与使用

Android系统提供了三种类型的c++智能指针，分别为轻量级指针（Light Pointer）、强指针（Strong Pointer）、弱指针（Weak Pointer）。其中，轻量级指针使用了简单的引用计数，而强指针和弱指针分别使用了强引用计数和弱引用计数。现在分析的是Android的轻量级指针的实现与简单应用。

一、LightRefBase类

如果一个类的对象支持使用轻量级指针，那么这个类在定义时必须继承LightRefBase类。LightRefBase类提供了一个简单的引用计数器，它的定义如下：

代码目录：framework/base/include/utils/RefBase.h

template <class T>
class LightRefBase
{
public:
inline LightRefBase() : mCount(0) { }
inline void incStrong(__attribute__((unused)) const void* id) const {
android_atomic_inc(&mCount); /*原子操作，不可被其他线程打断*/
}
inline void decStrong(__attribute__((unused)) const void* id) const {
if (android_atomic_dec(&mCount) == 1) /*原子操作，不可被其他线程打断*/ {
delete static_cast<const T*>(this); /*计数值为0，表示可以释放对象内存了*/
}
}
//! DEBUGGING ONLY: Get current strong ref count.
inline int32_t getStrongCount() const {
return mCount;
}

protected:
inline ~LightRefBase() { }

private:
mutable volatile int32_t mCount; /*对象的引用计数值*/
};

二、sp类

sp类在源代码中既是轻量级指针的实现类，也是强指针的实现类。这里只关注轻量级指针相关的代码：

代码目录：framework/base/include/utils/StrongPointer.h

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);

//! Special optimization for use by ProcessState (and nobody else).
void force_set(T* 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;
template<typename Y> friend class wp;
void set_pointer(T* ptr);
T* m_ptr; /*成员变量：模板指针*/
};

 

再来看看两个构造函数的具体实现：

template<typename T>
sp<T>::sp(T* other)
: m_ptr(other) /*普通构造函数：初始化成员变量m_ptr*/ {
if (other)
other->incStrong(this); /*增加引用计数*/
}

template<typename T>
sp<T>::sp(const sp<T>& other)
: m_ptr(other.m_ptr) /*拷贝构造函数：初始化成员变量m_ptr*/ {
if (m_ptr)
m_ptr->incStrong(this); /*增加引用计数*/
}

析构函数的实现：

template<typename T>
sp<T>::~sp() {
if (m_ptr)
m_ptr->decStrong(this); /*减少引用计数*/
}

二、简单应用

定义一个普通的Person类：

class Person {
private:
char *name ;

public:
Person() {
cout<<"Person()"<<endl ;
}

~Person() {
cout<<"~Person()"<<endl ;
}

void printInfo(void){
cout<<"just for test !"<<endl ;
}
} ;

在这个普通的Person类中，我们仅仅定义了几个普通的成员变量和普通的成员函数。这时该如何使这个类具有轻量级指针的功能呢？

1、要使这个类具有引用计数器，它在定义时必须继承LightRefBase这个模板类；

2、在使用时，先new 一个Person类，并创建一个轻量级指针来引用它；

3、接下来就可以操作Person类的成员函数了。

由于代码中用到了LightRefBase类、sp类，这两个类的定义与实现分别在RefBase.h 、StrongPointer.h ，而这两个文件在Android系统中是以库文件的形式存在的。它们位置在Android源码目录 system/core/include/utils 和 system/core/include/cutils目录下。因此，我们将这两个目录拷贝到当前应用程序目录的include目录下面。当前Person.cpp代码如下：

#include<iostream>
#include <utils/RefBase.h> /*包含RefBase.h文件，该文件中包含了StrongPointer.h，因此不必重复包含*/

using namespace std;
using namespace android; /*使用android命名空间*/

class Person : public LightRefBase<Person> /*要使这个类具有引用计数器，它在定义时必须继承LightRefBase这个模板类*/{
private:
char *name ;

public:
Person() {
cout<<"Person()"<<endl ;
}

~Person() {
cout<<"~Person()"<<endl ;
}

void printInfo(void){
cout<<"just for test !"<<endl ;
}
} ;

int main(int argc , char** argv)
{
/*使用轻量级指针*/
sp<Person> lp = new Person() ; /*普通构造*/
sp<Person> lp2 = lp ;	    /*拷贝构造*/
/*使用轻量级指针重载的运算符*/
lp->printInfo() ;
(*lp).printInfo() ;

lp2->printInfo() ;
(*lp2).printInfo() ;

return 0 ;
}

接下来在PC机上编译该Person.cpp : g++ -o Person Person.cpp -I include

发现如下错误：



在incStrong 和decStrong过程中的原子操作未定义。原因在于Android系统默认采用arm架构中的原子操作，而PC机采用x86架构，因此解决方法在RefBase.h 、StrongPointer.h 中将 #include <cutils/atomic.h> 改为 #include <cutils/atomic-x86.h> ，重新编译即可运行：



可以看到，析构函数正常执行，满足我们的预期。