本文主要是对 Flutter 引擎中的内存管理相关的源码进行解读，Flutter 引擎核心代码大都是用 C++ 写的，内存管理主要是引用计数，结合C++语言自己的灵活性，以不多的代码实现了相似于Objective-C语言的ARC的内存管理能力。html
C++代码中通常会遇到不少宏，咱们要理解这些宏的意义仍是须要参考其背后的源码，在内存模型相关的源码中遇到的宏，开篇以前咱们先作个简单的介绍， [flutter/engine/fml/macros.h]安全
宏名字自己就是最好的注释，C++中经过 delete来禁用copy, assign, move等函数。bash
#define FML_DISALLOW_COPY(TypeName) TypeName(const TypeName&) = delete
#define FML_DISALLOW_ASSIGN(TypeName) \ TypeName& operator=(const TypeName&) = delete
#define FML_DISALLOW_MOVE(TypeName) \ TypeName(TypeName&&) = delete; \ TypeName& operator=(TypeName&&) = delete
#define FML_DISALLOW_COPY_AND_ASSIGN(TypeName) \ TypeName(const TypeName&) = delete; \ TypeName& operator=(const TypeName&) = delete
#define FML_DISALLOW_COPY_ASSIGN_AND_MOVE(TypeName) \ TypeName(const TypeName&) = delete; \ TypeName(TypeName&&) = delete; \ TypeName& operator=(const TypeName&) = delete; \ TypeName& operator=(TypeName&&) = delete
#define FML_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \ TypeName() = delete; \ FML_DISALLOW_COPY_ASSIGN_AND_MOVE(TypeName)
复制代码
- flutter/engine/fml/memory
- ref_ptr.h
- ref_ptr_internal.h
- ref_counted.h
- ref_counted_internal.h
- weak_ptr.h
- weak_ptr_internal.h
- weak_ptr_internal.cc
- thread_checker.h
复制代码
咱们须要关注如下几个关键的概念：函数
引用指针能够指向继承了 RefCountedThreadSafe 的类的实例，并经过引用指针自己的入栈出栈来实现类实例的引用计数的增减。fetch
源码路径，[fml/memory/ref_counted_internal.h]ui
本类将做为全部使用引用计数的类的最开始的基类存在，主要提供引用计数最基本的三个能力：this
class RefCountedThreadSafeBase {
public:
void AddRef() const {
#ifndef NDEBUG
FML_DCHECK(!adoption_required_);
FML_DCHECK(!destruction_started_);
#endif
ref_count_.fetch_add(1u, std::memory_order_relaxed);
}
bool HasOneRef() const {
return ref_count_.load(std::memory_order_acquire) == 1u;
}
void AssertHasOneRef() const { FML_DCHECK(HasOneRef()); }
protected:
RefCountedThreadSafeBase();
~RefCountedThreadSafeBase();
// Returns true if the object should self-delete.
bool Release() const {
#ifndef NDEBUG
FML_DCHECK(!adoption_required_);
FML_DCHECK(!destruction_started_);
#endif
FML_DCHECK(ref_count_.load(std::memory_order_acquire) != 0u);
if (ref_count_.fetch_sub(1u, std::memory_order_release) == 1u) {
std::atomic_thread_fence(std::memory_order_acquire);
#ifndef NDEBUG
destruction_started_ = true;
#endif
return true;
}
return false;
}
#ifndef NDEBUG
void Adopt() {
FML_DCHECK(adoption_required_);
adoption_required_ = false;
}
#endif
private:
mutable std::atomic_uint_fast32_t ref_count_;
#ifndef NDEBUG
mutable bool adoption_required_;
mutable bool destruction_started_;
#endif
FML_DISALLOW_COPY_AND_ASSIGN(RefCountedThreadSafeBase);
};
inline RefCountedThreadSafeBase::RefCountedThreadSafeBase()
: ref_count_(1u)
#ifndef NDEBUG
,
adoption_required_(true),
destruction_started_(false)
#endif
{
}
inline RefCountedThreadSafeBase::~RefCountedThreadSafeBase() {
#ifndef NDEBUG
FML_DCHECK(!adoption_required_);
// Should only be destroyed as a result of |Release()|.
FML_DCHECK(destruction_started_);
#endif
}
复制代码
从类名看，就表示其是线程安全的，从源码层面，实现确保了 ref_count_ 的原子操做。atom
首先看下其定义：spa
mutable std::atomic_uint_fast32_t ref_count_;
复制代码
atomic_uint_fast32_t 其实是 std::atomic<uint_fast32_t>，表示当前类型能够进行原子操做。线程
其次，看AddRef的实现，这里用到了 std::memory_order_relaxed，仅保证此操做的原子性。
ref_count_.fetch_add(1u, std::memory_order_relaxed);
复制代码
一样的，在Release函数中，也会使用到确保操做原子性的调用。
ref_count_.fetch_sub(1u, std::memory_order_release);
复制代码
源码路径，[fml/memory/ref_counted.h]
RefCountedThreadSafe 将做为全部使用引用计数来管理内存的类的基类， 经过模板类型来引入实际的子类的类型。
template <typename T>
class RefCountedThreadSafe : public internal::RefCountedThreadSafeBase {
public:
void Release() const {
if (internal::RefCountedThreadSafeBase::Release())
delete static_cast<const T*>(this);
}
protected:
RefCountedThreadSafe() {}
~RefCountedThreadSafe() {}
private:
#ifndef NDEBUG
template <typename U>
friend RefPtr<U> AdoptRef(U*);
void Adopt() { internal::RefCountedThreadSafeBase::Adopt(); }
#endif
FML_DISALLOW_COPY_AND_ASSIGN(RefCountedThreadSafe);
};
复制代码
能够看到，在 Release 函数中最终会 delete 掉类实例的内存，也就是一旦引用计数为0的时候会立刻释放掉内存。
这里定义了一个友元函数，在 RefPtr中会看到起使用的场景。
template <typename U> friend RefPtr<U> AdoptRef(U*);
复制代码
源码路径，[fml/memory/ref_ptr.h]
RefPtr 是引用指针的实现类，须要关注的是各种构造、赋值、析构函数的行为。构造函数、拷贝构造函数须要 AddRef，转移构造函数不须要 AddRef；析构函数须要 Release；拷贝赋值函数AddRef 新的对象，Release 久的对象；转移赋值函数不须要变动引用计数。
AddRef 函数template <typename U>
explicit RefPtr(U* p) : ptr_(p) {
if (ptr_)
ptr_->AddRef();
}
RefPtr(const RefPtr<T>& r) : ptr_(r.ptr_) {
if (ptr_)
ptr_->AddRef();
}
复制代码
AddRefRefPtr(RefPtr<T>&& r) : ptr_(r.ptr_) { r.ptr_ = nullptr; }
template <typename U>
RefPtr(RefPtr<U>&& r) : ptr_(r.ptr_) {
r.ptr_ = nullptr;
}
复制代码
Release~RefPtr() {
if (ptr_)
ptr_->Release();
}
复制代码
AddRef 新的对象，Release 久的对象RefPtr<T>& operator=(const RefPtr<T>& r) {
// Call |AddRef()| first so self-assignments work.
if (r.ptr_)
r.ptr_->AddRef();
T* old_ptr = ptr_;
ptr_ = r.ptr_;
if (old_ptr)
old_ptr->Release();
return *this;
}
template <typename U>
RefPtr<T>& operator=(const RefPtr<U>& r) {
// Call |AddRef()| first so self-assignments work.
if (r.ptr_)
r.ptr_->AddRef();
T* old_ptr = ptr_;
ptr_ = r.ptr_;
if (old_ptr)
old_ptr->Release();
return *this;
}
复制代码
RefPtr<T>& operator=(RefPtr<T>&& r) {
RefPtr<T>(std::move(r)).swap(*this);
return *this;
}
template <typename U>
RefPtr<T>& operator=(RefPtr<U>&& r) {
RefPtr<T>(std::move(r)).swap(*this);
return *this;
}
复制代码
MakeRefCounted，这是提供给私有化构造函数的类建立对应指针的函数，这个函数会调用帮助类来实现
template <typename T, typename... Args>
RefPtr<T> MakeRefCounted(Args&&... args) {
return internal::MakeRefCountedHelper<T>::MakeRefCounted(
std::forward<Args>(args)...);
}
复制代码
template <typename T>
class MakeRefCountedHelper final {
public:
template <typename... Args>
static RefPtr<T> MakeRefCounted(Args&&... args) {
return AdoptRef<T>(new T(std::forward<Args>(args)...));
}
};
复制代码
而后实际的私有化构造函数的类须要将帮助类定义为友元类，通常经过以下的宏来完成
#define FML_FRIEND_MAKE_REF_COUNTED(T) \ friend class ::fml::internal::MakeRefCountedHelper<T>
复制代码
弱指针的设计比较有意思，增长了一个 WeakPtrFactory 来持有真正的指针，每次获取一个 WeakPtr 时，复制一份 WeakPtrFlag 来表示这个 WeakPtr 所指向指针的生命周期。
先来看 WeakPtrFlag，继承自RefCountedThreadSafe<WeakPtrFlag>，只是带了一个 is_valid_ 的简单类型，标记是否有效。
class WeakPtrFlag : public fml::RefCountedThreadSafe<WeakPtrFlag> {
public:
WeakPtrFlag() : is_valid_(true) {}
~WeakPtrFlag() {
FML_DCHECK(!is_valid_);
}
bool is_valid() const { return is_valid_; }
void Invalidate() {
FML_DCHECK(is_valid_);
is_valid_ = false;
}
private:
bool is_valid_;
FML_DISALLOW_COPY_AND_ASSIGN(WeakPtrFlag);
};
复制代码
再看看 WeakPtrFactory，最关键的函数是 GetWeakPtr，能够从 WeakPtrFactory 获取任意多个 WeakPtr，但都不会增长实例的引用计数
template <typename T>
class WeakPtrFactory {
public:
explicit WeakPtrFactory(T* ptr)
: ptr_(ptr), flag_(fml::MakeRefCounted<fml::internal::WeakPtrFlag>()) {
FML_DCHECK(ptr_);
}
~WeakPtrFactory() {
FML_DCHECK_CREATION_THREAD_IS_CURRENT(checker_.checker);
flag_->Invalidate();
}
WeakPtr<T> GetWeakPtr() const {
return WeakPtr<T>(ptr_, flag_.Clone(), checker_);
}
private:
T* const ptr_;
fml::RefPtr<fml::internal::WeakPtrFlag> flag_;
DebugThreadChecker checker_;
FML_DISALLOW_COPY_AND_ASSIGN(WeakPtrFactory);
};
复制代码
再看看 WeakPtr 自己的实现，主要关注如下几个函数就能够了，特别是要知道这端代码，*this 实际上会经过 explicit operator bool() const 进行转换。
explicit operator bool() const {
FML_DCHECK_CREATION_THREAD_IS_CURRENT(checker_.checker);
return flag_ && flag_->is_valid();
}
T* get() const {
FML_DCHECK_CREATION_THREAD_IS_CURRENT(checker_.checker);
return *this ? ptr_ : nullptr;
}
T& operator*() const {
FML_DCHECK_CREATION_THREAD_IS_CURRENT(checker_.checker);
FML_DCHECK(*this);
return *get();
}
T* operator->() const {
FML_DCHECK_CREATION_THREAD_IS_CURRENT(checker_.checker);
FML_DCHECK(*this);
return get();
}
复制代码
源码路径，[fml/memory/thread_checker.h]
ThreadChecker 很是简单，仅提供了判断是不是当前线程的一个函数，能够再源码上看到不少地方会使用到。
// Returns true if the current thread is the thread this object was created
// on and false otherwise.
bool IsCreationThreadCurrent() const {
return !!pthread_equal(pthread_self(), self_);
}
复制代码
#if !defined(NDEBUG) && false
#define FML_DECLARE_THREAD_CHECKER(c) fml::ThreadChecker c
#define FML_DCHECK_CREATION_THREAD_IS_CURRENT(c) \ FML_DCHECK((c).IsCreationThreadCurrent())
#else
#define FML_DECLARE_THREAD_CHECKER(c)
#define FML_DCHECK_CREATION_THREAD_IS_CURRENT(c) ((void)0)
#endif
复制代码
Flutter引擎设计的 RefPtr 和 WeakPtr 仍是比较小巧的，并且二者之间耦合没有标准库的 shared_ptr 和 weak_ptr 那么大。
WeakPtr 是对 RefPtr 的一种辅助，同时也是必不可少的，在不一样线程间共享数据的时候，WeakPtr 才是更应该使用的方式。
WeakPtr 经过 WeakPtrFactory 的生命周期来管理实例的生命周期，通常咱们会把 WeakPtrFactory 放置到实例的类下面，这就达到了实例本身销毁的时候 WeakPtrFactory 也会随之销毁，全部的弱指针天然没法再指向实例，实现方式跟标准款的 weak_ptr 是彻底不同的，不愧为一种好方案。
整个实现方案也是完美的利用了 C++ 的 RAII 技术。