[实验4_C++指针]_[3_C++智能指针]
第3章，智能指针
问：为什么需要使用智能指针？
答：主要是为了解决使用C++时，忘记释放指针指向的对象所占用的内存，或者使用了无效指针，造成内存泄漏，甚至系统崩溃。
问：为什么Android系统的应用程序框架层还要使用C++语言呢？
答：C++语言编译出的程序性能较Java语言高。
问：智能指针的基本原理是什么？
答：智能指针是一种能够自动维护对象引用计数的技术，智能指针是一个对象，而不是一个指针，但是它引用了一个实际使用的对象。智能指针能够自动地维护实际对象的引用计数，在智能指针构造时，增加它所引用的对象的引用计数；在智能指针析构时，减少它所引用的对象的引用计数。由于智能指针的构造和析构都是自动的，因此，它就很自然地实现了自动的对象引用计数技术。
问：为什么需要引入强引用计数和弱引用计数？
答：为了解决对象之前互相引用，导致对象无法被释放的问题。
3.1，轻量级指针
轻量级指针通过简单的引用计数技术来维护对象的声明周期。如果一个类的对象支持使用轻量级指针，那么它就必须要从 LightRefBase 类继承下来，因为 LightRefBase 类提供了一个简单的引用计数器。
3.1.1.实现原理分析
RefBase.h
文件路径：frameworks/base/include/utils/RefBase.h
备注：这里仅仅列出 轻量级指针 涉及的代码，源文件不止这么多代码。
/* LightRefBase 类是一个模板类，其中，模板参数 T 表示对象的实际类型。*/
template <class T>
class LightRefBase
{
public:
/* 成员变量 mCount，用来描述一个对象的引用计数值。 */
inline LightRefBase() : mCount(0) { }
/* incStrong 增加它所引用的对象的引用计数; */
inline void incStrong(const void* id) const {
android_atomic_inc(&mCount);
}
/* decStrong 减少它所引用的对象的引用计数; */
inline void decStrong(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 类是一个模板类，其中，模板参数 T 表示对象的实际类型。
*/
template <typename T>
class sp
{
public:
/* 使用 RefBase::weakref_type 类来维护它所引用的对象的强引用计数和弱引用计数; */
typedef typename RefBase::weakref_type weakref_type;
/* 成员变量 m_ptr 是一个指针，指向实际引用的对象。 */
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;
// Optimization for wp::promote().
sp(T* p, weakref_type* refs);
T* m_ptr;
};
/* sp类的构造函数，首先初始化 m_ptr，然后调用 m_ptr 的成员函数 incStrong 来增加它的引用计数。*/
template<typename T>
sp<T>::sp(T* other)
: m_ptr(other)
{
if (other) other->incStrong(this);
}
template<typename T>
sp<T>::sp(const sp<T>& other)
: m_ptr(other.m_ptr)
{
if (m_ptr) m_ptr->incStrong(this);
}
template<typename T> template<typename U>
sp<T>::sp(U* other) : m_ptr(other)
{
if (other) other->incStrong(this);
}
template<typename T> template<typename U>
sp<T>::sp(const sp<U>& other)
: m_ptr(other.m_ptr)
{
if (m_ptr) m_ptr->incStrong(this);
}
/* sp类的析构函数，调用成员变量 m_ptr 的成员函数 decStrong 减少对象的引用计数。 */
template<typename T>
sp<T>::~sp()
{
if (m_ptr) m_ptr->decStrong(this);
}
template<typename T>
sp<T>& sp<T>::operator = (const sp<T>& other) {
T* otherPtr(other.m_ptr);
if (otherPtr) otherPtr->incStrong(this);
if (m_ptr) m_ptr->decStrong(this);
m_ptr = otherPtr;
return *this;
}
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)
{
U* otherPtr(other.m_ptr);
if (otherPtr) otherPtr->incStrong(this);
if (m_ptr) m_ptr->decStrong(this);
m_ptr = otherPtr;
return *this;
}
template<typename T> template<typename U>
sp<T>& sp<T>::operator = (U* other)
{
if (other) other->incStrong(this);
if (m_ptr) m_ptr->decStrong(this);
m_ptr = other;
return *this;
}
3.1.2.应用实例分析
我们在 aosp/external 目录中建立一个 C++ 应用程序 lightpointer 来说明轻量级指针的使用方法，它的目录结构如下：
~/aosp
----external
----lightpointer
----lightpointer.cpp
----Android.mk
lightpointer.cpp
文件路径：aosp/external/lightpointer/lightpointer.cpp
#include <stdio.h>
#include <utils/RefBase.h>
using namespace android;
/* LightClass 继承了 LightRefBase类 */
class LightClass : public LightRefBase<LightClass>
{
public:
LightClass()
{
printf("Construct LightClass Object.\n");
}
virtual ~LightClass()
{
printf("Destory LightClass Object.\n");
}
};
int main(int argc, char** argv)
{
LightClass* pLightClass = new LightClass();
/* 创建轻量级指针 lpOut 引用 LightRefBase */
sp<LightClass> lpOut = pLightClass;
/* 经过构造函数的调用，引用计数值为1; */
printf("Light Ref Count: %d.\n", pLightClass->getStrongCount());
{
/* 新建一个轻量级指针 lpInner 来引用 loOut 对象，引用计数增加1; */
sp<LightClass> lpInner = lpOut;
/* 经过构造函数和lpInner的指向，计数器为2; */
printf("Light Ref Count: %d.\n", pLightClass->getStrongCount());
} // 当走出括号，lpInner 被析构，引用计数减少1;
/* 经过构造函数和lpInner的指向，然后lpInner被析构，计数器为1; */
printf("Light Ref Count: %d.\n", pLightClass->getStrongCount());
return 0;
}
Android.mk
文件路径：aosp/external/lightpointer/Android.mk
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE_TAGS := optional
LOCAL_MODULE := lightpointer
LOCAL_SRC_FILES := lightpointer.cpp
LOCAL_SHARED_LIBRARIES := \
libcutils \
libutils
include $(BUILD_EXECUTABLE)
这是应用程序 lightpointer 的编译脚本文件，它引用了 libcutils 和 libutils 两个库。
编译&运行
dt@ubuntu:~/2.3.1_r1$ mmm ./external/lightpointer/
============================================
PLATFORM_VERSION_CODENAME=REL
PLATFORM_VERSION=2.3.1
TARGET_PRODUCT=generic
TARGET_BUILD_VARIANT=eng
TARGET_SIMULATOR=
TARGET_BUILD_TYPE=release
TARGET_BUILD_APPS=
TARGET_ARCH=arm
HOST_ARCH=x86
HOST_OS=linux
HOST_BUILD_TYPE=release
BUILD_ID=GRH78
============================================
make: Entering directory `/home/dt/2.3.1_r1'
target thumb C++: lightpointer <= external/lightpointer/lightpointer.cpp
target Executable: lightpointer (out/target/product/generic/obj/EXECUTABLES/lightpointer_intermediates/LINKED/lightpointer)
target Non-prelinked: lightpointer (out/target/product/generic/symbols/system/bin/lightpointer)
target Strip: lightpointer (out/target/product/generic/obj/EXECUTABLES/lightpointer_intermediates/lightpointer)
Install: out/target/product/generic/system/bin/lightpointer
make: Leaving directory `/home/dt/2.3.1_r1'
dt@ubuntu:~/2.3.1_r1$ make snod
============================================
PLATFORM_VERSION_CODENAME=REL
PLATFORM_VERSION=2.3.1
TARGET_PRODUCT=generic
TARGET_BUILD_VARIANT=eng
TARGET_SIMULATOR=
TARGET_BUILD_TYPE=release
TARGET_BUILD_APPS=
TARGET_ARCH=arm
HOST_ARCH=x86
HOST_OS=linux
HOST_BUILD_TYPE=release
BUILD_ID=GRH78
============================================
Install: out/host/linux-x86/bin/mkyaffs2image
make snod: ignoring dependencies
Target system fs image: out/target/product/generic/system.img
dt@ubuntu:~/goldfish$ cp out/target/product/generic/system.img /mnt/hgfs/AndroidEmulator/images/system.img
[win]> pushd d:\AndroidEmulator
[win]> start /b emulator.exe -sysdir d:\AndroidEmulator -system images\system.img -data images\userdata.img -ramdisk images\ramdisk.img -kernel images\zImage -skindir d:\AndroidEmulator\skins -skin HVGA
[win]> adb shell
# cd /system/bin
# ./lightpointer
Construct LightClass Object.
Light Ref Count: 1.
Light Ref Count: 2.
Light Ref Count: 1.
Destory LightClass Object.
#
3.2.强指针和弱指针
强指针和弱指针通过强引用计数和弱引用计数来维护对象的声明周期。如果一个类的对象要支持使用强指针和弱指针，那么它就必须从 RefBase 类继承下来，因为 Refbase 类提供了强引用计数器和弱引用计数器。
3.2.1,强指针的实现原理分析
RefBase类
文件路径: frameworks/base/include/utils/RefBase.h
备注：这里仅仅列出 轻量级指针 涉及的代码，源文件不止这么多代码。
class RefBase
{
public:
void incStrong(const void* id) const;
void decStrong(const void* id) const;
void forceIncStrong(const void* id) const;
//! DEBUGGING ONLY: Get current strong ref count.
int32_t getStrongCount() const;
class weakref_type
{
public:
RefBase* refBase() const;
void incWeak(const void* id);
void decWeak(const void* id);
bool attemptIncStrong(const void* id);
//! This is only safe if you have set OBJECT_LIFETIME_FOREVER.
bool attemptIncWeak(const void* id);
//! DEBUGGING ONLY: Get current weak ref count.
int32_t getWeakCount() const;
//! DEBUGGING ONLY: Print references held on object.
void printRefs() const;
//! DEBUGGING ONLY: Enable tracking for this object.
// enable -- enable/disable tracking
// retain -- when tracking is enable, if true, then we save a stack trace
// for each reference and dereference; when retain == false, we
// match up references and dereferences and keep only the
// outstanding ones.
void trackMe(bool enable, bool retain);
};
weakref_type* createWeak(const void* id) const;
weakref_type* getWeakRefs() const;
//! DEBUGGING ONLY: Print references held on object.
inline void printRefs() const { getWeakRefs()->printRefs(); }
//! DEBUGGING ONLY: Enable tracking of object.
inline void trackMe(bool enable, bool retain)
{
getWeakRefs()->trackMe(enable, retain);
}
protected:
RefBase();
virtual ~RefBase();
//! Flags for extendObjectLifetime()
enum {
OBJECT_LIFETIME_WEAK = 0x0001,
OBJECT_LIFETIME_FOREVER = 0x0003
};
void extendObjectLifetime(int32_t mode);
//! Flags for onIncStrongAttempted()
enum {
FIRST_INC_STRONG = 0x0001
};
virtual void onFirstRef();
virtual void onLastStrongRef(const void* id);
virtual bool onIncStrongAttempted(uint32_t flags, const void* id);
virtual void onLastWeakRef(const void* id);
private:
friend class weakref_type;
class weakref_impl;
RefBase(const RefBase& o);
RefBase& operator=(const RefBase& o);
/* 使用一个 weakref_impl 类型的成员变量 mRefs 来描述对象的引用计数; */
weakref_impl* const mRefs;
};
与 LightRefBase 类一样，RefBase 类也提供了成员函数 incStrong 和 decStrong 来维护它所引用的对象的引用计数。不过，RefBase 类与 LightRefBase 类不一样，它不是直接使用一个整数来维护对象的引用计数的，而是使用一个 weakref_impl 对象，即成员变量 mRefs 来描述对象的引用计数。
weakref_impl 类同时为对象提供了强引用计数和弱引用计数。
weakref_impl类
文件路径: frameworks/base/libs/utils/RefBase.cpp
备注：这里仅仅列出 轻量级指针 涉及的代码，源文件不止这么多代码。
/* weakref_impl 类继承了 weakref_type 类*/
class RefBase::weakref_impl : public RefBase::weakref_type
{
public:
volatile int32_t mStrong;
volatile int32_t mWeak;
RefBase* const mBase;
volatile int32_t mFlags;
#if !DEBUG_REFS
weakref_impl(RefBase* base)
: mStrong(INITIAL_STRONG_VALUE)
, mWeak(0)
, mBase(base)
, mFlags(0)
{
}
void addStrongRef(const void* /*id*/) { }
void removeStrongRef(const void* /*id*/) { }
void addWeakRef(const void* /*id*/) { }
void removeWeakRef(const void* /*id*/) { }
void printRefs() const { }
void trackMe(bool, bool) { }
#else
......
#endif
};
weakref_impl 类继承了 weakref_type 类。weakref_type 类定义在 RefBase 类的内部，它提供了成员函数 incWeak、decWeak、attemptIncStrong 和 attemptIncWeak 来维护对象的强引用计数和弱引用计数。weakref_type 类只定义了引用计数维护接口（操作函数），具体的实现（操作对象）是由 weakref_impl 类提供的。
weakref_impl 类有两个成员变量 mStrong 和 mWeak 分别用来描述对象的强引用计数和弱引用计数。同时，weakref_impl 类的成员变量 mBase 指向了它所引用的对象的地址，而成员变量 mFlags 是一个标志值，用来描述对象的生命周期控制方式。weakref_impl 类的成员变量 mFlags 的取值范围为 0、OBJECT_LIFE_TIME_WEAK 或者 OBJECT_LIFETIME_FOREVER，其中，0 表示对象的声明周期只受强引用计数影响；OBJECT_LIFETIME_WEAK 表示对象的声明周期同时受强引用计数和弱引用计数影响；OBJECT_LIFETIME_FOREVER 表示对象的声明周期完全不受强引用计数或者弱引用计数影响。
sp类的构造函数
文件路径：frameworks/base/include/utils/RefBase.h
template<typename T>
sp<T>::sp(T* other)
: m_ptr(other)
{
if (other) other->incStrong(this);
}
模块参数 T 是一个继承了 RefBase 类的子类，因此，第5行实际上是调用了 RefBase 类的成员函数 incStrong 来增加对象的强引用计数，如下所示：
frameworks/base/libs/utils/RefBase.cpp
#define INITIAL_STRONG_VALUE (1<<28)
void RefBase::incStrong(const void* id) const
{
weakref_impl* const refs = mRefs;
refs->addWeakRef(id);
refs->incWeak(id); // 增加对象的弱引用计数;
refs->addStrongRef(id);
const int32_t c = android_atomic_inc(&refs->mStrong); // 增加对象的强引用计数;
LOG_ASSERT(c > 0, "incStrong() called on %p after last strong ref", refs);
#if PRINT_REFS
LOGD("incStrong of %p from %p: cnt=%d\n", this, id, c);
#endif
/* 若 c != INITIAL_STRONG_VALUE 说明该对象不是第一次被引用，INITIAL_STRONG_VALUE是mStrong的初值; */
if (c != INITIAL_STRONG_VALUE) {
/* 不是第一次被引用，直接退出函数; */
return;
}
/* 下面的逻辑：是第一次被引用，会调用onFirstRef接口; */
android_atomic_add(-INITIAL_STRONG_VALUE, &refs->mStrong);
/* 如果发现对象是第一次被强指针引用，则调用对象的成员函数 onFristRef 来通知对象，
* 它被强指针引用了，以便它可以执行一些业务相关逻辑;
* RefBase类的成员函数 onFristRef 是一个空实现，如果子类想要处理这个事件，
* 那么就必须要重写成员函数 onFristRef 。
*/
const_cast<RefBase*>(this)->onFirstRef();
}
增加对象的弱引用计数是通过调用 RefBase 类的成员变量 mRefs 的成员函数 incWeak 来实现的。RefBase类的成员变量 mRefs 的类型为 weakref_impl，它的成员函数 incWeak 是从父类 weakref_type 继承下来的，因此，它实际上是通过调用 weakref_type 类的成员函数 incWeak 来增加对象的弱引用计数的。如下所示：
frameworks/base/libs/utils/RefBase.cpp
void RefBase::weakref_type::incWeak(const void* id)
{
/* this 指针指向的实际上是一个 weakref_impl 对象; */
weakref_impl* const impl = static_cast<weakref_impl*>(this);
impl->addWeakRef(id);
const int32_t c = android_atomic_inc(&impl->mWeak); // 增加对象的弱引用计数;
LOG_ASSERT(c >= 0, "incWeak called on %p after last weak ref", this);
}
Refbase类的成员变量 mRefs 是在构造函数中初始化的，如下所示：
frameworks/base/libs/utils/RefBase.cpp
RefBase::RefBase()
: mRefs(new weakref_impl(this))
{
// LOGV("Creating refs %p with RefBase %p\n", mRefs, this);
}
sp类的析构函数
文件路径：frameworks/base/include/utils/RefBase.h
template<typename T>
sp<T>::~sp()
{
/* m_ptr 所指向的对象是继承了 RefBase 类的，因此下面实际是调用了
* RefBase类的成员函数 decStrong 来减少对象的强引用计数;
*/
if (m_ptr) m_ptr->decStrong(this);
}
文件路径: frameworks/base/libs/utils/RefBase.cpp
void RefBase::decStrong(const void* id) const
{
weakref_impl* const refs = mRefs;
refs->removeStrongRef(id);
const int32_t c = android_atomic_dec(&refs->mStrong); //真正减少强引用计数的地方
#if PRINT_REFS
LOGD("decStrong of %p from %p: cnt=%d\n", this, id, c);
#endif
LOG_ASSERT(c >= 1, "decStrong() called on %p too many times", refs);
if (c == 1) { // 强引用计数只剩下一个时，执行下面逻辑，会调用被引用用对象的onLastStrongRef方法
const_cast<RefBase*>(this)->onLastStrongRef(id);
if ((refs->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK) {
delete this; /* 释放对象所占用的内存，同时会导致RefBase类的析构函数被调用; */
}
}
refs->removeWeakRef(id);
refs->decWeak(id); //减少弱引用计数
}
RefBase::~RefBase()
{
// LOGV("Destroying RefBase %p (refs %p)\n", this, mRefs);
if (mRefs->mWeak == 0) {
/* 如果对象的弱引用计数值为0，那么就把引用计数对象 mRefs 也一起释放; */
// LOGV("Freeing refs %p of old RefBase %p\n", mRefs, this);
delete mRefs;
}
}
void RefBase::weakref_type::decWeak(const void* id)
{
weakref_impl* const impl = static_cast<weakref_impl*>(this);
impl->removeWeakRef(id); // 空函数,调试用;
const int32_t c = android_atomic_dec(&impl->mWeak); // 减少对象的弱引用计数;
LOG_ASSERT(c >= 1, "decWeak called on %p too many times", this);
if (c != 1) return;
/* 如果 c 的值不等于 1，那么说明还有其他的弱指针在引用这个对象，则不再做处理，直接返回; */
/* 走到这里，说明没有弱指针引用这个对象了，也没有强指针引用这个对象了。
* 基于对象的生命周期控制方式，确认该对象是否要释放掉;
*/
if ((impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK) {
/* 生命周期只受强引用计数控制; */
if (impl->mStrong == INITIAL_STRONG_VALUE)
delete impl->mBase; /* 强引用计数为0，则释放; */
else {
// LOGV("Freeing refs %p of old RefBase %p\n", this, impl->mBase);
delete impl;
}
} else {
/* 生命周期受弱引用计数控制，先调用 onLastWeakRef 处理逻辑； */
impl->mBase->onLastWeakRef(id);
if ((impl->mFlags&OBJECT_LIFETIME_FOREVER) != OBJECT_LIFETIME_FOREVER) {
/* 如果生命周期控制不是 OBJECT_LIFETIME_FOREVER，则释放内存；*/
delete impl->mBase;
} /* 如果生命周期控制是 OBJECT_LIFETIME_FOREVER，即对象的生命周期完全不受强引用计数
* 和弱引用计数控制时，智能指针就退化成一个普通的 C++ 指针了，需要开发人员手动释放内存。
*/
}
}
对象的生命周期控制方式小结
（1）如果一个对象的生命周期控制标志值被设置为0，那么只要它的强引用计数值为0，系统就会自动释放这个对象。
（2）如果一个对象的生命周期控制标志值被设置为 OBJECT_LIFETIME_WEAK，那么只有当它的强引用计数值和弱引用计数值都为0时，系统才会自动释放这个对象。
（3）如果一个对象的生命周期控制标志值被设置为 OBJECT_LIFETIME_FOREVER，那么系统就永远不会自动释放这个对象，它需要由开发人员来手动地释放。
3.2.2,弱指针的实现原理分析
如果一个类的对象支持使用弱指针，那么这个类就必须要从 RefBase 类继承下来，因为 RefBase 类提供了弱引用计数器。
wp类的定义
文件路径：frameworks/base/include/utils/RefBase.h
/* wp类是一个模板类，模板参数 T 表示对象的实际类型，它必须是从 RefBase 类继承下来的。 */
template <typename T>
class wp
{
public:
/* weakref_type 用来维护对象的弱引用计数; */
typedef typename RefBase::weakref_type weakref_type;
/* m_ptr 用来指向它所引用的对象; */
inline wp() : m_ptr(0) { }
wp(T* other);
wp(const wp<T>& other);
wp(const sp<T>& other);
template<typename U> wp(U* other);
template<typename U> wp(const sp<U>& other);
template<typename U> wp(const wp<U>& other);
~wp();
// Assignment
wp& operator = (T* other);
wp& operator = (const wp<T>& other);
wp& operator = (const sp<T>& other);
template<typename U> wp& operator = (U* other);
template<typename U> wp& operator = (const wp<U>& other);
template<typename U> wp& operator = (const sp<U>& other);
void set_object_and_refs(T* other, weakref_type* refs);
// promotion to sp
sp<T> promote() const;
// Reset
void clear();
// Accessors
inline weakref_type* get_refs() const { return m_refs; }
inline T* unsafe_get() const { return m_ptr; }
// Operators
COMPARE_WEAK(==)
COMPARE_WEAK(!=)
COMPARE_WEAK(>)
COMPARE_WEAK(<)
COMPARE_WEAK(<=)
COMPARE_WEAK(>=)
inline bool operator == (const wp<T>& o) const {
return (m_ptr == o.m_ptr) && (m_refs == o.m_refs);
}
template<typename U>
inline bool operator == (const wp<U>& o) const {
return m_ptr == o.m_ptr;
}
inline bool operator > (const wp<T>& o) const {
return (m_ptr == o.m_ptr) ? (m_refs > o.m_refs) : (m_ptr > o.m_ptr);
}
template<typename U>
inline bool operator > (const wp<U>& o) const {
return (m_ptr == o.m_ptr) ? (m_refs > o.m_refs) : (m_ptr > o.m_ptr);
}
inline bool operator < (const wp<T>& o) const {
return (m_ptr == o.m_ptr) ? (m_refs < o.m_refs) : (m_ptr < o.m_ptr);
}
template<typename U>
inline bool operator < (const wp<U>& o) const {
return (m_ptr == o.m_ptr) ? (m_refs < o.m_refs) : (m_ptr < o.m_ptr);
}
inline bool operator != (const wp<T>& o) const { return m_refs != o.m_refs; }
template<typename U> inline bool operator != (const wp<U>& o) const { return !operator == (o); }
inline bool operator <= (const wp<T>& o) const { return !operator > (o); }
template<typename U> inline bool operator <= (const wp<U>& o) const { return !operator > (o); }
inline bool operator >= (const wp<T>& o) const { return !operator < (o); }
template<typename U> inline bool operator >= (const wp<U>& o) const { return !operator < (o); }
private:
template<typename Y> friend class sp;
template<typename Y> friend class wp;
T* m_ptr;
weakref_type* m_refs;
};
弱指针与强指针有一个很大的区别，就是弱指针不可以直接操作它所引用的对象，因为它所引用的对象可能是不受弱引用计数控制的，即它所引用的对象可能是一个无效的对象。因此，如果需要操作一个弱指针所引用的对象，那么就需要将这个弱指针升级为强指针，这是通过调用它的成员函数 promote 来实现的。如果升级成功，就说明该弱指针所引用的对象还没有被销毁，可以正常使用。
wp类的构造函数
文件路径：frameworks/base/include/utils/RefBase.h
template<typename T>
wp<T>::wp(T* other)
: m_ptr(other)
{
// 实际调用 RefBase类的成员函数 createWeak 来增加对象的弱引用计数;
if (other) m_refs = other->createWeak(this);
}
frameworks/base/libs/utils/RefBase.cpp
RefBase::weakref_type* RefBase::createWeak(const void* id) const
{
/* RefBase类的成员变量 mRefs 指向的是一个 weakref_impl 对象;
* incWeak 是增加实际引用对象的弱引用计数;
*/
mRefs->incWeak(id);
return mRefs;
}
wp类的析构函数
文件路径：frameworks/base/include/utils/RefBase.h
template<typename T>
wp<T>::~wp()
{
/* m_refs 指向一个 weakref_impl 对象，下面调用了 weakref_impl 类的 decWeak 来减少对象的弱引用计数; */
if (m_ptr) m_refs->decWeak(this);
}
wp类的成员函数promote，弱指针升级为强指针
wp类没有重载*和-＞操作符号，所以不能直接操作它所引用的对象。
promote函数实现：
文件路径：frameworks/base/include/utils/RefBase.h
template<typename T>
sp<T> wp<T>::promote() const
{
/* 弱指针升级为强指针的方式是通过内部的成员变量 m_prt 和 m_refs 来创建一个强指针; */
return sp<T>(m_ptr, m_refs);
}
template<typename T>
sp<T>::sp(T* p, weakref_type* refs)
: m_ptr((p && refs->attemptIncStrong(this)) ? p : 0)
{
/* 参数 p 指向对象的地址，而参数 regs 指向对象内部的一个弱引用计数器对象;
* 只有在对象地址不为 NULL 的情况下，才会调用它内部的弱引用计数对象的成员函数 attemptIncStrong 来试图增加该对象的强引用计数;
* 如果能够成功增加对象的强引用计数，那么就可以成功地把一个弱指针升级为一个强指针了。
* 参数 refs 是一个类型为 weakref_type 的指针，即会调用 weakref_type 类的成员函数 attemptIncStrong;
*/
}
attemptIncStrong函数实现：
文件路径：frameworks/base/libs/utils/RefBase.cpp
/* attemptIncStrong 试图增加目标对象的强引用计数，但是可能会增加失败，因为目标对象
* 可能已经被释放了，或者该目标对象不允许使用强指针引用它。
*/
bool RefBase::weakref_type::attemptIncStrong(const void* id)
{
incWeak(id); // 调用 incWeak 来增加对象的弱引用计数;
/* 将 this 指针转换为一个 weakref_impl 指针，保存在 impl 中; */
weakref_impl* const impl = static_cast<weakref_impl*>(this);
int32_t curCount = impl->mStrong;
LOG_ASSERT(curCount >= 0, "attemptIncStrong called on %p after underflow",
this);
/* 该对象正在被其他强指针所引用，即它的强引用计数值大于0，并且不等于 INITIAL_STRONG_VALUE; */
while (curCount > 0 && curCount != INITIAL_STRONG_VALUE) {
/* 直接将对象的强引用计数值增加1;
* android_atomic_cmpxchg 定义在 system/core/include/cutils/atomic.h 文件;
* #define android_atomic_cmpxchg android_atomic_release_cas
* int android_atomic_release_cas(int32_t oldvalue, int32_t newvalue, volatile int32_t* addr);
* => system/core/include/cutils/atomic-arm.h
* extern inline int android_atomic_release_cas(int32_t old_value,
* int32_t new_value,
* volatile int32_t *ptr)
* {
* android_memory_barrier();
* return android_atomic_cas(old_value, new_value, ptr);
* }
* android_atomic_cas 函数依据不同的CPU类型，执行不同的实现函数。
*
* android_atomic_release_cas 的工作原理：如果它发现地址 addr 的内容等于参数 oldvalue 的值，
* 那么它就会将地址 addr 的内容修改为 newvalue，然后给调用者返回 0，表示修改地址 addr 的内容成功；
* 否则，就什么也不做，然后给调用者返回 1 。
* 下面这一行，是增加对象的强引用计数，如果增加失败，则循环执行；
*/
if (android_atomic_cmpxchg(curCount, curCount+1, &impl->mStrong) == 0) {
break;
}
curCount = impl->mStrong;
}
if (curCount <= 0 || curCount == INITIAL_STRONG_VALUE) {
bool allow;
if (curCount == INITIAL_STRONG_VALUE) {
/* 对象的强引用计数值为 INITIAL_STRONG_VALUE，说明这个对象从来没有被强指针引用过;
* 下面根据对象的声明周期控制方式或者对象的实现来判断是否允许将一个引用了它的弱指针升级为强指针。
* 如果对象的生命周期只受强引用计数影响，那么就可以成功地将该弱指针升级为强指针；
*
*/
// Attempting to acquire first strong reference... this is allowed
// if the object does NOT have a longer lifetime (meaning the
// implementation doesn't need to see this), or if the implementation
// allows it to happen.
allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK
|| impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);
} else {
/*
* 如果对象的强引用计数值小于等于0，说明对象之前被强指针引用过，因此，就必须要保证对象的生命周期受到弱引用计数的影响；
* 否则，对象就已经被释放了。
* 如果对象的生命周期受弱引用计数影响，那么说明对象现在肯定是存在的；
* 需要调用 onIncStrongAttempted 确认对象是否允许强指针引用它;
* 如果 onIncStrongAttempted 返回 ture，就说明允许使用强指针来引用它，这种情况可以成功地将弱指针升级为强指针;
*/
// Attempting to revive the object... this is allowed
// if the object DOES have a longer lifetime (so we can safely
// call the object with only a weak ref) and the implementation
// allows it to happen.
allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_WEAK
&& impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);
}
if (!allow) {
/* 如果 allow 的值为 false，那就说明弱指针升级为强指针失败，于是
* 减少对象的弱引用计数，然后返回false;
*/
decWeak(id);
return false;
}
/* 运行到这里，说明 allow 为 true，即 弱指针升级为强指针成功；
* 下面增加对象的强引用计数;
*/
curCount = android_atomic_inc(&impl->mStrong);
// If the strong reference count has already been incremented by
// someone else, the implementor of onIncStrongAttempted() is holding
// an unneeded reference. So call onLastStrongRef() here to remove it.
// (No, this is not pretty.) Note that we MUST NOT do this if we
// are in fact acquiring the first reference.
if (curCount > 0 && curCount < INITIAL_STRONG_VALUE) {
impl->mBase->onLastStrongRef(id);
}
}
impl->addWeakRef(id);
impl->addStrongRef(id);
#if PRINT_REFS
LOGD("attemptIncStrong of %p from %p: cnt=%d\n", this, id, curCount);
#endif
if (curCount == INITIAL_STRONG_VALUE) {
android_atomic_add(-INITIAL_STRONG_VALUE, &impl->mStrong);
impl->mBase->onFirstRef();
}
return true;
}
bool RefBase::onIncStrongAttempted(uint32_t flags, const void* id)
{
return (flags&FIRST_INC_STRONG) ? true : false;
}
3.2.3,应用实例分析
我们在external目录下建立一个C++应用程序weightpointer来说明强指针和弱指针的使用方法，它的目录结构如下:
~/aosp
----external
----weightpointer
----weightpointer.cpp
----Android.mk
weightpointer.cpp
文件路径: aosp/external/weightpointer/weightpointer.cpp
#include <stdio.h>
#include <utils/RefBase.h>
#define INITIAL_STRONG_VALUE (1<<28)
using namespace android;
class WeightClass : public RefBase
{
public:
void printRefCount() // 打印对象的引用计数，包括强引用计数和弱引用计数;
{
int32_t strong = getStrongCount();
weakref_type* ref = getWeakRefs();
printf("-----------------------\n");
printf("Strong Ref Count: %d.\n", (strong == INITIAL_STRONG_VALUE ? 0 : strong));
printf("Weak Ref Count: %d.\n", ref->getWeakCount());
printf("-----------------------\n");
}
};
class StrongClass : public WeightClass
{
public:
StrongClass()
{
printf("Construct StrongClass Object.\n");
}
virtual ~StrongClass()
{
printf("Destory StrongClass Object.\n");
}
};
class WeakClass : public WeightClass
{
public:
WeakClass()
{
extendObjectLifetime(OBJECT_LIFETIME_WEAK); // 对象的生命周期同时受到强引用计数和弱引用计数的影响;
printf("Construct WeakClass Object.\n");
}
virtual ~WeakClass()
{
printf("Destory WeakClass Object.\n");
}
};
class ForeverClass : public WeightClass
{
public:
ForeverClass()
{
extendObjectLifetime(OBJECT_LIFETIME_FOREVER); // 对象的生命周期完全不受强引用计数和弱引用计数的影响;
printf("Construct ForeverClass Object.\n");
}
virtual ~ForeverClass()
{
printf("Destory ForeverClass Object.\n");
}
};
void TestStrongClass(StrongClass* pStrongClass)
{
wp<StrongClass> wpOut = pStrongClass; // 将一个 StrongClass 对象赋值给一个弱指针 wpOut;
pStrongClass->printRefCount(); // 打印出该 StrongClass 对象的强引用计数值和弱引用计数值;（0和1）
{
sp<StrongClass> spInner = pStrongClass; // 将该 StrongClass对象赋值给一个强指针 spInner;
pStrongClass->printRefCount(); // 打印出该 StrongClass 对象的强引用计数值和弱引用计数值;（1和2）
}
sp<StrongClass> spOut = wpOut.promote(); // spInner被析构,且由于对象 StrongClass 对象的生命周期只受强引用计数的影响，这里强引用计数为0，那么该StrongClass对象会自动被释放; 下面试图将弱指针 wpOut 升级为 强指针，但是由于弱指针 wpOut 所引用的 StrongClass 对象已经被释放，因此，弱指针 wpOut 升级为强指针就会失败;
printf("spOut: %p.\n", spOut.get());
}
void TestWeakClass(WeakClass* pWeakClass)
{
wp<WeakClass> wpOut = pWeakClass; // 将一个 WeakClass 对象赋值给一个弱指针，因此该 WeakClass 对象的强引用计数值和弱引用计数值应该分别为0和1；
pWeakClass->printRefCount();
{
sp<WeakClass> spInner = pWeakClass; // 将该 WeakClass 对象赋值给一个强指针 spInner；
pWeakClass->printRefCount(); // 该 WeakClass 对象的强引用计数值和弱引用计数值分别为1和2;
}
// spInner被析构，该 WeakClass 对象的强引用计数值和弱引用计数值应该分别为0和1；由于该 WeakClass 对象的生命周期同时受强引用计数和弱引用计数的影响，因此，此时该 WeakClass 对象不会被释放。
pWeakClass->printRefCount();
sp<WeakClass> spOut = wpOut.promote(); // 试图将弱指针 wpOut 升级为 强指针，由于弱指针 wpOut 所引用的 WeakClass 对象还存在，因此，弱指针 wpOut 就能够成功升级为强指针 spOut;
printf("spOut: %p.\n", spOut.get()); // 该 WeakClass 对象的强引用计数值和弱引用计数值应该分别为1和2；
}
void TestForeverClass(ForeverClass* pForeverClass)
{
wp<ForeverClass> wpOut = pForeverClass; // 将一个 ForeverClass 对象赋值给一个弱指针 wpOut，因此，该 ForeverClass 对象的强引用计数值和弱引用计数值分别为0和1;
pForeverClass->printRefCount();
{
sp<ForeverClass> spInner = pForeverClass; // 将该 ForeverClass 对象赋值给一个强指针 spInner；
pForeverClass->printRefCount(); // 该 ForeverClass 对象的强引用计数值和弱引用计数值分别为1和2;
}
// spInner被析构，该 ForeverClass 对象的强引用计数值和弱引用计数值应该分别为0和1；由于该 ForeverClass 对象的生命周期不受强引用计数和弱引用计数的影响，因此，此时该 ForeverClass 对象不会被释放。
// 当 TestForeverClass 函数返回，wpOut被析构，该 ForeverClass 对象的强引用计数值和弱引用计数值应该分别为0和0；由于该 ForeverClass 对象的生命周期不受强引用计数和弱引用计数的影响，因此，此时该 ForeverClass 对象不会被释放。
}
int main(int argc, char** argv)
{
printf("Test Strong Class: \n");
StrongClass* pStrongClass = new StrongClass();
TestStrongClass(pStrongClass);
printf("\nTest Weak Class: \n");
WeakClass* pWeakClass = new WeakClass();
TestWeakClass(pWeakClass);
printf("\nTest Froever Class: \n");
ForeverClass* pForeverClass = new ForeverClass();
TestForeverClass(pForeverClass);
pForeverClass->printRefCount();
delete pForeverClass;
return 0;
}
Android.mk
文件路径: aosp/external/weightpointer/Android.mk
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE_TAGS := optional
LOCAL_MODULE := weightpointer
LOCAL_SRC_FILES := weightpointer.cpp
LOCAL_SHARED_LIBRARIES := \
libcutils \
libutils
include $(BUILD_EXECUTABLE)
Android.mk是应用程序 weightpointer 的编译脚本文件，它引用了 libcutils 和 libutils 两个库。
编译&运行
dt@ubuntu:~/2.3.1_r1$ export PATH=$PATH:/home/dt/2.3.1_r1/out/host/linux-x86/bin
dt@ubuntu:~/2.3.1_r1$ source build/envsetup.sh
including device/htc/passion/vendorsetup.sh
including device/samsung/crespo/vendorsetup.sh
dt@ubuntu:~/2.3.1_r1$ mmm ./external/weightpointer
============================================
PLATFORM_VERSION_CODENAME=REL
PLATFORM_VERSION=2.3.1
TARGET_PRODUCT=generic
TARGET_BUILD_VARIANT=eng
TARGET_SIMULATOR=
TARGET_BUILD_TYPE=release
TARGET_BUILD_APPS=
TARGET_ARCH=arm
HOST_ARCH=x86
HOST_OS=linux
HOST_BUILD_TYPE=release
BUILD_ID=GRH78
============================================
make: Entering directory `/home/dt/2.3.1_r1`
target thumb C++: weightpointer <= external/weightpointer/weightpointer.cpp
target Executable: weightpointer (out/target/product/generic/obj/EXECUTABLES/weightpointer_intermediates/LINKED/weightpointer)
target Non-prelinked: weightpointer (out/target/product/generic/symbols/system/bin/weightpointer)
target Strip: weightpointer (out/target/product/generic/obj/EXECUTABLES/weightpointer_intermediates/weightpointer)
Install: out/target/product/generic/system/bin/weightpointer
make: Leaving directory `/home/dt/2.3.1_r1`
dt@ubuntu:~/2.3.1_r1$ make snod
============================================
PLATFORM_VERSION_CODENAME=REL
PLATFORM_VERSION=2.3.1
TARGET_PRODUCT=generic
TARGET_BUILD_VARIANT=eng
TARGET_SIMULATOR=
TARGET_BUILD_TYPE=release
TARGET_BUILD_APPS=
TARGET_ARCH=arm
HOST_ARCH=x86
HOST_OS=linux
HOST_BUILD_TYPE=release
BUILD_ID=GRH78
============================================
Install: out/host/linux-x86/bin/mkyaffs2image
make snod: ignoring dependencies
Target system fs image: out/target/product/generic/system.img
dt@ubuntu:~/2.3.1_r1$ cp out/target/product/generic/system.img /mnt/hgfs/AndroidEmulator/images/system.img
[win]> pushd d:\AndroidEmulator
[win]> start /b emulator.exe -sysdir d:\AndroidEmulator -system images\system.img -data images\userdata.img -ramdisk images\ramdisk.img -kernel images\zImage -skindir d:\AndroidEmulator\skins -skin HVGA
[win]> adb shell
# cd /system/bin
# ./weightpointer
Test Strong Class:
Construct StrongClass Object.
-----------------------
Strong Ref Count: 0.
Weak Ref Count: 1.
-----------------------
-----------------------
Strong Ref Count: 1.
Weak Ref Count: 2.
-----------------------
Destory StrongClass Object.
spOut: 0x0.
Test Weak Class:
Construct WeakClass Object.
-----------------------
Strong Ref Count: 0.
Weak Ref Count: 1.
-----------------------
-----------------------
Strong Ref Count: 1.
Weak Ref Count: 2.
-----------------------
-----------------------
Strong Ref Count: 0.
Weak Ref Count: 1.
-----------------------
spOut: 0xa528.
Destory WeakClass Object.
Test Froever Class:
Construct ForeverClass Object.
-----------------------
Strong Ref Count: 0.
Weak Ref Count: 1.
-----------------------
-----------------------
Strong Ref Count: 1.
Weak Ref Count: 2.
-----------------------
-----------------------
Strong Ref Count: 0.
Weak Ref Count: 0.
-----------------------
Destory ForeverClass Object.
#
找找Android源码中使用智能指针的场景
在 Android15.0.0_r1 中搜索 onFirstRef 关键字，然后粗略定位哪些模块使用了智能指针：
/frameworks/av/services/audiopolicy/service/AudioRecordClient.cpp
/frameworks/native/services/sensorservice/SensorDeviceUtils.cpp
/hardware/interfaces/broadcastradio/1.0/default/BroadcastRadio.cpp
/system/libhwbinder/BpHwBinder.cpp
/frameworks/av/services/audioflinger/PatchCommandThread.cpp
/frameworks/av/services/audioflinger/DeviceEffectManager.cpp
/hardware/interfaces/soundtrigger/2.0/default/SoundTriggerHalImpl.cpp
/hardware/interfaces/soundtrigger/2.2/default/SoundTriggerHw.cpp
/hardware/interfaces/soundtrigger/2.3/default/SoundTriggerHw.cpp
/frameworks/av/media/libaudiohal/impl/DevicesFactoryHalHidl.cpp
/frameworks/native/services/sensorservice/SensorDirectConnection.cpp
/frameworks/base/core/jni/android_hardware_SensorManager.cpp
/frameworks/native/libs/binder/BpBinder.cpp
/frameworks/av/services/audioflinger/MelReporter.cpp
/frameworks/native/services/sensorservice/SensorEventConnection.cpp
/frameworks/av/services/audiopolicy/service/Spatializer.cpp
/frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp
/system/libhidl/transport/ServiceManagement.cpp
/frameworks/base/cmds/bootanimation/BootAnimation.cpp
/frameworks/native/libs/gui/SurfaceComposerClient.cpp
/frameworks/av/media/libaudioclient/AudioTrack.cpp
从上面过滤的文件可以看出，开机动画 bootanimation 模块，使用了智能指针；然后就是传感器 sensor 模块，应该也使用了，还有就是音频模块。