Flutter引擎源碼解讀-內存管理篇

時間  2020-05-09
標籤 flutter 引擎 源碼 解讀 內存 管理 简体版
原文   原文鏈接

摘要

本文主要是對 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
複製代碼

關鍵概念

咱們須要關注如下幾個關鍵的概念：函數

  • 引用指針，引用計數的實現就是經過引用指針指向實例，實例對引用進行計數以管理內存的釋放；
  • 弱指針，一樣的咱們須要有弱指針來表示對一個內存的引用不會增長引用計數；
  • Thread Safe，在內存管理相關的層面上，咱們須要關注指針是不是線程安全的

引用指針

引用指針能夠指向繼承了 RefCountedThreadSafe 的類的實例，並經過引用指針自己的入棧出棧來實現類實例的引用計數的增減。fetch

RefCountedThreadSafeBase

源碼路徑，[fml/memory/ref_counted_internal.h]ui

本類將做爲全部使用引用計數的類的最開始的基類存在，主要提供引用計數最基本的三個能力：this

  • ref_count_，在初始化時會默認爲1u
  • AddRef，增長引用計數，同時確保操做的原子性
  • Release，減小引用計數，同時確保操做的原子性
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);
複製代碼

RefCountedThreadSafe

源碼路徑，[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*);
複製代碼

RefPtr

源碼路徑，[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();
  }
複製代碼
  • 轉移構造函數不會調用 AddRef
RefPtr(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

先來看 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

再看看 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

再看看 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 技術。

std::atomic

std::atomic::fetch_add

std::memory_order

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程