【C++】Android (Light)RefBase-sp-wp引用计数-智能指针源码分析
文章目录
- 1、RefBase简介
- 2、RefBase源码分析
- 3、RefBase使用注意事项
- 4、总结
1、RefBase简介
什么是RefBase？RefBase是Android中的一个C++类，用于内存管理，相关的类还包括LightRefBase、sp和wp。在Android源码中的许多地方都可以看到RefBase的使用，那么，为什么RefBase这么受欢迎呢？这源于C++的指针与动态内存管理，指针本身就是一个复杂的概念，而动态内存管理又提高了其复杂性，new一般情况下与delete配对使用，防止内存泄漏，但在大型项目中很难保证这一点，于是各种奇奇怪怪的问题就来了；不像其它语言如Java一样，有gc机制，对不再使用的对象会自动回收内存，不必担心内存泄漏问题，但是，C++注重性能，而gc势必会影响性能，所以需要开发者格外注意；这样，RefBase来了，通过引用计数原理，解放开发者对内存泄漏问题的过多担心，自动delete不再使用的对象。
2、RefBase源码分析
RefBase源码位置在Android中的system/core/libutils目录下，属于libutils库的内容，相关头文件在system/core/include/utils，下面是源码分析。
/**
* @file RefBase.h
* Copyright: Android Open Source Project
* License: Apache 2.0
*/
#ifndef ANDROID_REF_BASE_H
#define ANDROID_REF_BASE_H
// Location: external/libcxx/include
// C++11原子操作
#include
// Location: bionic/libc/include
#include
#include
#include
#include
// Locaion: system/core/include
#include
#include
// ---------------------------------------------------------------------------
namespace android {
// Location: system/libhwbinder
// 抽象类
class TextOutput;
TextOutput& printWeakPointer(TextOutput& to, const void* val);
// ---------------------------------------------------------------------------
// 用于wp的宏
// 简化了比较操作符的定义
#define COMPARE_WEAK(_op_) \
inline bool operator _op_ (const sp& o) const { \
return m_ptr _op_ o.m_ptr; \
} \
inline bool operator _op_ (const T* o) const { \
return m_ptr _op_ o; \
} \
template \
inline bool operator _op_ (const sp& o) const { \
return m_ptr _op_ o.m_ptr; \
} \
template \
inline bool operator _op_ (const U* o) const { \
return m_ptr _op_ o; \
}
// ---------------------------------------------------------------------------
// 忽略push与pop之间的编译警告
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wweak-vtables"
#endif
/**
* @class ReferenceRenamer
* operator() 纯虚函数
* 非虚析构函数（故意为之）避免派生类的代码开销
*/
class ReferenceRenamer
{
protected:
~ReferenceRenamer() {}
public:
virtual void operator()(size_t i) const = 0;
};
#if defined(__clang__)
#pragma clang diagnostic pop
#endif
// ---------------------------------------------------------------------------
/**
* @class RefBase
* 引用计数基类
*/
class RefBase
{
public:
void incStrong(const void* id) const; // 增加强引用计数
void decStrong(const void* id) const; // 减少强引用计数
void forceIncStrong(const void* id) const; // 强制增加强引用计数
int32_t getStrongCount() const; // 获取当前强引用计数（只用于debug）
/**
* @class weakref_type
* 弱引用计数类型
*/
class weakref_type
{
public:
RefBase* refBase() const; // 获取引用计数基类指针
void incWeak(const void* id); // 增加弱引用计数
void decWeak(const void* id); // 减少弱引用计数
bool attemptIncStrong(const void* id); // 获取强引用
bool attemptIncWeak(const void* id); // 获取弱引用（可能不安全）
int32_t getWeakCount() const; // 获取当前弱引用计数（只用于debug）
void printRefs() const; // 打印引用计数相关信息（只用于debug）
/**
* @fn trackMe: 跟踪引用计数信息
* @param enable: true-跟踪 false-不跟踪
* @param retain: true-跟踪所有的 false-跟踪最新的
* @note 只用于debug
*/
void trackMe(bool enable, bool retain);
};
weakref_type* createWeak(const void* id) const; // 创建弱引用计数类型
weakref_type* getWeakRefs() const; // 获取弱引用计数类型指针
inline void printRefs() const { getWeakRefs()->printRefs(); } // 打印引用计数相关信息（只用于debug）
inline void trackMe(bool enable, bool retain) // 跟踪引用计数信息（只用于debug）
{
getWeakRefs()->trackMe(enable, retain);
}
typedef RefBase basetype; // typedef别名
protected:
RefBase(); // protected构造（使用时需派生子类）
virtual ~RefBase(); // 虚析构
// 用于extendObjectLifetime()
enum {
OBJECT_LIFETIME_STRONG = 0x0000,
OBJECT_LIFETIME_WEAK = 0x0001,
OBJECT_LIFETIME_MASK = 0x0001
};
void extendObjectLifetime(int32_t mode); // 扩展对象生命期
// 用于 onIncStrongAttempted()
enum {
FIRST_INC_STRONG = 0x0001
};
/**
* 四个回调
* @fn onFirstRef: 强指针/引用初始化后回调
* @fn onLastStrongRef: 最后一个强引用不再使用时或者需要取消不必要的onIncStrongAttempted的影响时
* @fn onIncStrongAttempted: 生命期为OBJECT_LIFETIME_WEAK
* @return true-成功转化为强指针时（可能有副作用）
× @param flags: [TO-BE-REMOVED]FIRST_INC_STRONG
* @fn onLastWeakRef: [TO-BE-REMOVED]生命期为OBJECT_LIFETIME_WEAK且最后一个引用不再使用时
*/
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.cpp中定义
RefBase(const RefBase& o); // 拷贝构造（无定义-禁止拷贝）
RefBase& operator=(const RefBase& o); // 赋值操作符（无定义-禁止赋值）
private:
friend class ReferenceMover; // 下面有定义
// 三个用于修改引用属性的静态函数
static void renameRefs(size_t n, const ReferenceRenamer& renamer);
static void renameRefId(weakref_type* ref, const void* old_id, const void* new_id);
static void renameRefId(RefBase* ref, const void* old_id, const void* new_id);
weakref_impl* const mRefs; // 唯一的成员变量（定义隐藏在cpp中为常说的句柄）
};
// ---------------------------------------------------------------------------
/**
* @class LightRefBase
* 轻量级的RefBase（少了不少多西）
* 原子操作使用了C++11
*/
template
class LightRefBase
{
public:
inline LightRefBase() : mCount(0) {}
inline void incStrong(__attribute__((unused)) const void* id) const {
mCount.fetch_add(1, std::memory_order_relaxed);
}
inline void decStrong(__attribute__((unused)) const void* id) const {
if (mCount.fetch_sub(1, std::memory_order_release) == 1) {
std::atomic_thread_fence(std::memory_order_acquire);
delete static_cast(this);
}
}
inline int32_t getStrongCount() const { // 只用于debug
return mCount.load(std::memory_order_relaxed);
}
typedef LightRefBase basetype;
protected:
inline ~LightRefBase() {}
private:
friend class ReferenceMover;
inline static void renameRefs(size_t /*n*/, const ReferenceRenamer& /*renamer*/) {}
inline static void renameRefId(T* /*ref*/, const void* /*old_id*/, const void* /*new_id*/) {}
private:
mutable std::atomic mCount;
};
/**
* @class VirtualLightRefBase
* 使用LightRefBase进行包装
* 只是声明了虚析构函数以消除LightRefBase的模板需求
*/
// This is a wrapper around LightRefBase that simply enforces a virtual
// destructor to eliminate the template requirement of LightRefBase
class VirtualLightRefBase : public LightRefBase
{
public:
virtual ~VirtualLightRefBase();
};
// ---------------------------------------------------------------------------
/**
* @class wp
*/
template
class wp
{
public:
// 模板中经常使用typename声明其后的内容为一种数据类型
typedef typename RefBase::weakref_type weakref_type;
// 构造
inline wp() : m_ptr(0) {}
// （拷贝）构造
wp(T* other); // NOLINT(implicit)
wp(const wp& other);
explicit wp(const sp& other);
template wp(U* other); // NOLINT(implicit)
template wp(const sp& other); // NOLINT(implicit)
template wp(const wp& other); // NOLINT(implicit)
// 析构
~wp();
// 赋值操作符
wp& operator = (T* other);
wp& operator = (const wp& other);
wp& operator = (const sp& other);
template wp& operator = (U* other);
template wp& operator = (const wp& other);
template wp& operator = (const sp& other);
// 同时设置对象和引用
void set_object_and_refs(T* other, weakref_type* refs);
// 转换为强指针
sp promote() const;
// 清空wp保存的对象指针
void clear();
// 获取弱引用类型指针/获取wp保存的对象指针
inline weakref_type* get_refs() const { return m_refs; }
inline T* unsafe_get() const { return m_ptr; }
// 比较操作符
COMPARE_WEAK(==)
COMPARE_WEAK(!=)
COMPARE_WEAK(>)
COMPARE_WEAK(<)
COMPARE_WEAK(<=)
COMPARE_WEAK(>=)
inline bool operator == (const wp& o) const {
return (m_ptr == o.m_ptr) && (m_refs == o.m_refs);
}
template
inline bool operator == (const wp& o) const {
return m_ptr == o.m_ptr;
}
inline bool operator > (const wp& o) const {
return (m_ptr == o.m_ptr) ? (m_refs > o.m_refs) : (m_ptr > o.m_ptr);
}
template
inline bool operator > (const wp& o) const {
return (m_ptr == o.m_ptr) ? (m_refs > o.m_refs) : (m_ptr > o.m_ptr);
}
inline bool operator < (const wp& o) const {
return (m_ptr == o.m_ptr) ? (m_refs < o.m_refs) : (m_ptr < o.m_ptr);
}
template
inline bool operator < (const wp& o) const {
return (m_ptr == o.m_ptr) ? (m_refs < o.m_refs) : (m_ptr < o.m_ptr);
}
inline bool operator != (const wp& o) const { return m_refs != o.m_refs; }
template inline bool operator != (const wp& o) const { return !operator == (o); }
inline bool operator <= (const wp& o) const { return !operator > (o); }
template inline bool operator <= (const wp& o) const { return !operator > (o); }
inline bool operator >= (const wp& o) const { return !operator < (o); }
template inline bool operator >= (const wp& o) const { return !operator < (o); }
private:
// （其它的）sp<>和wp<>为友元
template friend class sp;
template friend class wp;
// wp保存的对象指针和对应的弱引用类型指针
T* m_ptr;
weakref_type* m_refs;
};
// 为TextOutput重载operator<<
template
TextOutput& operator<<(TextOutput& to, const wp& val);
#undef COMPARE_WEAK
// ---------------------------------------------------------------------------
// 下面是（拷贝）构造的几种形式
// 需要注意若引用更新
template
wp::wp(T* other)
: m_ptr(other)
{
if (other) m_refs = other->createWeak(this);
}
template
wp::wp(const wp& other)
: m_ptr(other.m_ptr), m_refs(other.m_refs)
{
if (m_ptr) m_refs->incWeak(this);
}
template
wp::wp(const sp& other)
: m_ptr(other.m_ptr)
{
if (m_ptr) {
m_refs = m_ptr->createWeak(this);
}
}
template template
wp::wp(U* other)
: m_ptr(other)
{
if (other) m_refs = other->createWeak(this);
}
template template
wp::wp(const wp& other)
: m_ptr(other.m_ptr)
{
if (m_ptr) {
m_refs = other.m_refs;
m_refs->incWeak(this);
}
}
template template
wp::wp(const sp& other)
: m_ptr(other.m_ptr)
{
if (m_ptr) {
m_refs = m_ptr->createWeak(this);
}
}
// 析构函数减少弱引用但不直接delete对象指针m_ptr
// 在decWeak中当若引用减少到1时自动delete
template
wp::~wp()
{
if (m_ptr) m_refs->decWeak(this);
}
// 下面是重载的operator =的几种形式
// 需要注意新、旧对象的若引用更新
template
wp& wp::operator = (T* other)
{
weakref_type* newRefs =
other ? other->createWeak(this) : 0;
if (m_ptr) m_refs->decWeak(this);
m_ptr = other;
m_refs = newRefs;
return *this;
}
template
wp& wp::operator = (const wp& other)
{
weakref_type* otherRefs(other.m_refs);
T* otherPtr(other.m_ptr);
if (otherPtr) otherRefs->incWeak(this);
if (m_ptr) m_refs->decWeak(this);
m_ptr = otherPtr;
m_refs = otherRefs;
return *this;
}
template
wp& wp::operator = (const sp& other)
{
weakref_type* newRefs =
other != NULL ? other->createWeak(this) : 0;
T* otherPtr(other.m_ptr);
if (m_ptr) m_refs->decWeak(this);
m_ptr = otherPtr;
m_refs = newRefs;
return *this;
}
template template
wp& wp::operator = (U* other)
{
weakref_type* newRefs =
other ? other->createWeak(this) : 0;
if (m_ptr) m_refs->decWeak(this);
m_ptr = other;
m_refs = newRefs;
return *this;
}
template template
wp& wp::operator = (const wp& other)
{
weakref_type* otherRefs(other.m_refs);
U* otherPtr(other.m_ptr);
if (otherPtr) otherRefs->incWeak(this);
if (m_ptr) m_refs->decWeak(this);
m_ptr = otherPtr;
m_refs = otherRefs;
return *this;
}
template template
wp& wp::operator = (const sp& other)
{
weakref_type* newRefs =
other != NULL ? other->createWeak(this) : 0;
U* otherPtr(other.m_ptr);
if (m_ptr) m_refs->decWeak(this);
m_ptr = otherPtr;
m_refs = newRefs;
return *this;
}
// 保存对象指针和若引用类型指针时
// 需要对other和m_ptr分别进行减少、增加弱引用处理
template
void wp::set_object_and_refs(T* other, weakref_type* refs)
{
if (other) refs->incWeak(this);
if (m_ptr) m_refs->decWeak(this);
m_ptr = other;
m_refs = refs;
}
// 把对象指针m_ptr提升为强指针
template
sp wp::promote() const
{
sp result;
if (m_ptr && m_refs->attemptIncStrong(&result)) {
result.set_pointer(m_ptr);
}
return result;
}
// 清空对象指针m_ptr并减少弱引用
template
void wp::clear()
{
if (m_ptr) {
m_refs->decWeak(this);
m_ptr = 0;
}
}
// 重载了TextOutput的operator<<
template
inline TextOutput& operator<<(TextOutput& to, const wp& val)
{
return printWeakPointer(to, val.unsafe_get());
}
// ---------------------------------------------------------------------------
/**
* @class ReferenceMover
*/
class ReferenceMover
{
public:
template static inline
void move_references(sp* dest, sp const* src, size_t n) {
/**
* @class Renamer
* for sp
*/
class Renamer : public ReferenceRenamer
{
sp* d_;
sp const* s_;
virtual void operator()(size_t i) const {
// The id are known to be the sp<>'s this pointer
TYPE::renameRefId(d_[i].get(), &s_[i], &d_[i]);
}
public:
Renamer(sp* d, sp const* s) : d_(d), s_(s) {}
virtual ~Renamer() {}
};
memmove(dest, src, n * sizeof(sp));
TYPE::renameRefs(n, Renamer(dest, src));
}
template static inline
void move_references(wp* dest, wp const* src, size_t n) {
/**
* @class Renamer
* for wp
*/
class Renamer : public ReferenceRenamer {
wp* d_;
wp const* s_;
virtual void operator()(size_t i) const {
TYPE::renameRefId(d_[i].get_refs(), &s_[i], &d_[i]);
}
public:
Renamer(wp* rd, wp const* rs) : d_(rd), s_(rs) {}
virtual ~Renamer() {}
};
memmove(dest, src, n * sizeof(wp));
TYPE::renameRefs(n, Renamer(dest, src));
}
};
template inline
void move_forward_type(sp* d, sp const* s, size_t n) {
ReferenceMover::move_references(d, s, n);
}
template inline
void move_backward_type(sp* d, sp const* s, size_t n) {
ReferenceMover::move_references(d, s, n);
}
template inline
void move_forward_type(wp* d, wp const* s, size_t n) {
ReferenceMover::move_references(d, s, n);
}
template inline
void move_backward_type(wp* d, wp const* s, size_t n) {
ReferenceMover::move_references(d, s, n);
}
}; // namespace android
// ---------------------------------------------------------------------------
#endif // ANDROID_REF_BASE_H
/**
* @file StrongPointer.h
* Copyright: Android Open Source Project
* License: Apache 2.0
*/
#ifndef ANDROID_STRONG_POINTER_H
#define ANDROID_STRONG_POINTER_H
// Location: system/core/include
// Android包装的原子操作接口（使用了GCC的原子特性）
#include
// Location: bionic/libc/include
#include
#include
#include
// ---------------------------------------------------------------------------
namespace android {
// wp<>模板类前置声明
template class wp;
// ---------------------------------------------------------------------------
// 用于sp<>的比较操作符
#define COMPARE(_op_) \
inline bool operator _op_ (const sp& o) const { \
return m_ptr _op_ o.m_ptr; \
} \
inline bool operator _op_ (const T* o) const { \
return m_ptr _op_ o; \
} \
template \
inline bool operator _op_ (const sp& o) const { \
return m_ptr _op_ o.m_ptr; \
} \
template \
inline bool operator _op_ (const U* o) const { \
return m_ptr _op_ o; \
} \
inline bool operator _op_ (const wp& o) const { \
return m_ptr _op_ o.m_ptr; \
} \
template \
inline bool operator _op_ (const wp& o) const { \
return m_ptr _op_ o.m_ptr; \
}
// ---------------------------------------------------------------------------
/**
* @class sp
*/
template
class sp
{
public:
// 构造
inline sp() : m_ptr(0) {}
// （拷贝）构造
sp(T* other); // NOLINT(implicit)
sp(const sp& other);
sp(sp&& other);
template sp(U* other); // NOLINT(implicit)
template sp(const sp& other); // NOLINT(implicit)
template sp(sp&& other); // NOLINT(implicit)
// 析构
~sp();
// 赋值操作符
sp& operator = (T* other);
sp& operator = (const sp& other);
sp& operator = (sp&& other);
template sp& operator = (const sp& other);
template sp& operator = (sp&& other);
template sp& operator = (U* other);
// 专门用于ProcessState
void force_set(T* other);
// 重置对象指针
void clear();
// 访问对象指针
inline T& operator* () const { return *m_ptr; }
inline T* operator-> () const { return m_ptr; }
inline T* get() const { return m_ptr; }
// 比较操作符
COMPARE(==)
COMPARE(!=)
COMPARE(>)
COMPARE(<)
COMPARE(<=)
COMPARE(>=)
private:
// 友元声明
template friend class sp;
template friend class wp;
// 保存对象指针
void set_pointer(T* ptr);
// 对象指针
T* m_ptr;
};
#undef COMPARE
// ---------------------------------------------------------------------------
// 下面是sp<>的（拷贝）构造的几种形式
// 需要注意C++11的右值引用（移动拷贝）
template
sp::sp(T* other)
: m_ptr(other)
{
if (other)
other->incStrong(this);
}
template
sp::sp(const sp& other)
: m_ptr(other.m_ptr)
{
if (m_ptr)
m_ptr->incStrong(this);
}
template
sp::sp(sp&& other)
: m_ptr(other.m_ptr)
{
other.m_ptr = nullptr;
}
template template
sp::sp(U* other)
: m_ptr(other)
{
if (other)
(static_cast(other))->incStrong(this);
}
template template
sp::sp(const sp& other)
: m_ptr(other.m_ptr)
{
if (m_ptr)
m_ptr->incStrong(this);
}
template template
sp::sp(sp&& other)
: m_ptr(other.m_ptr)
{
other.m_ptr = nullptr;
}
// 析构时减少强引用但不在这里进行真正地delete对象指针m_ptr
// 当decStrong时强引用计数为1时自动delete
template
sp::~sp()
{
if (m_ptr)
m_ptr->decStrong(this);
}
// 下面是operator =的几种形式
// 需要注意强引用计数的更新及右值引用
template
sp& sp::operator =(const sp& other)
{
T* otherPtr(other.m_ptr);
if (otherPtr)
otherPtr->incStrong(this);
if (m_ptr)
m_ptr->decStrong(this);
m_ptr = otherPtr;
return *this;
}
template
sp& sp::operator =(sp&& other)
{
if (m_ptr)
m_ptr->decStrong(this);
m_ptr = other.m_ptr;
other.m_ptr = nullptr;
return *this;
}
template
sp& sp::operator =(T* other)
{
if (other)
other->incStrong(this);
if (m_ptr)
m_ptr->decStrong(this);
m_ptr = other;
return *this;
}
template template
sp& sp::operator =(const sp& other)
{
T* otherPtr(other.m_ptr);
if (otherPtr)
otherPtr->incStrong(this);
if (m_ptr)
m_ptr->decStrong(this);
m_ptr = otherPtr;
return *this;
}
template template
sp& sp::operator =(sp&& other)
{
if (m_ptr)
m_ptr->decStrong(this);
m_ptr = other.m_ptr;
other.m_ptr = nullptr;
return *this;
}
template template
sp& sp::operator =(U* other)
{
if (other)
(static_cast(other))->incStrong(this);
if (m_ptr)
m_ptr->decStrong(this);
m_ptr = other;
return *this;
}
// 强制保存对象指针并增加强引用计数
template
void sp::force_set(T* other)
{
other->forceIncStrong(this);
m_ptr = other;
}
// 重置对象指针并减少强引用计数
template
void sp::clear()
{
if (m_ptr) {
m_ptr->decStrong(this);
m_ptr = 0;
}
}
// 简单地保存对象指针
template
void sp::set_pointer(T* ptr)
{
m_ptr = ptr;
}
}; // namespace android
// ---------------------------------------------------------------------------
#endif // ANDROID_STRONG_POINTER_H
/**
* @file TypeHelpers.h
* 用于处理C++数据类型相关特性
* Copyright: Android Open Source Project
* License: Apache 2.0
*/
#ifndef ANDROID_TYPE_HELPERS_H
#define ANDROID_TYPE_HELPERS_H
#include
#include
#include
#include
#include
// ---------------------------------------------------------------------------
namespace android {
// 类型特性包括ctor/dtor/copy/move/pointer
template struct trait_trivial_ctor { enum { value = false }; };
template struct trait_trivial_dtor { enum { value = false }; };
template struct trait_trivial_copy { enum { value = false }; };
template struct trait_trivial_move { enum { value = false }; };
template struct trait_pointer { enum { value = false }; };
template struct trait_pointer { enum { value = true }; };
template
struct traits {
enum {
// 这个类型是否为指针
is_pointer = trait_pointer::value,
// 这个类型的构造是否为空操作
has_trivial_ctor = is_pointer || trait_trivial_ctor::value,
// 这个类型的析构是否为空操作
has_trivial_dtor = is_pointer || trait_trivial_dtor::value,
// 这个类型是否可以通过memcpy进行拷贝构造
has_trivial_copy = is_pointer || trait_trivial_copy::value,
// 这个类型是否可以通过memmove进行移动构造
has_trivial_move = is_pointer || trait_trivial_move::value
};
};
// 聚合了两种类型
template
struct aggregate_traits {
enum {
is_pointer = false,
has_trivial_ctor =
traits