Androidシステムのスマートポインタ(軽量ポインタ、強ポインタ、弱ポインタ)の実現原理分析(4)

23614 ワード
Android スマートポインタ 原理を実現する
外層のif文に戻り、ターゲットオブジェクトのライフサイクルが弱い参照カウントによって制御されている場合は、次の文を実行します.
   
   
   
   
    
    
    
    
    
  1. impl->mBase->onLastWeakRef(id);   
    2. 
    
    
    
    
  2. if ((impl->mFlags&OBJECT_LIFETIME_FOREVER) != OBJECT_LIFETIME_FOREVER) {   
    3. 
    
    
    
    
  3.     delete impl->mBase;   
    4. 
    
    
    
    
  4. }   
    5.

理論的には、ターゲットオブジェクトのライフサイクルが弱い参照カウントによって制御されている場合、強い参照カウントと弱い参照カウントが両方とも0の場合、deleteターゲットオブジェクトが必要になりますが、ここではもう1つの制御があり、ターゲット対象のフラグ値をOBJECT_に設定することができます.LIFETIME_FOREVER、すなわちターゲットオブジェクトのライフサイクルが強参照カウントと弱参照カウントに全く制御されていない場合、ターゲットオブジェクトの強参照カウントと弱参照カウントが同時に0であっても、ここではdeleteというターゲットオブジェクトはできません.では、誰がdeleteを落とすのでしょうか.もちろん誰がnewから出てきたのか、誰がdeleteに来たのか、この時スマートポインタは完全に普通のポインタに退化し、ここのスマートポインタは非常に強く設計されています.
 
ここまで分析すると、小結する必要があります.
A.オブジェクトのフラグビットが0に設定されている場合、オブジェクトの強い参照カウント値が0であることを発見すると、自動的にdeleteがこのオブジェクトを削除します.
B.オブジェクトのフラグビットがOBJECT_に設定されている場合LIFETIME_WEAKでは、オブジェクトの強い参照カウントと弱い参照カウントが0の場合にのみ、自動的にdeleteがこのオブジェクトを削除します.
C.オブジェクトのフラグビットがOBJECT_に設定されている場合LIFETIME_FOREVERでは、オブジェクトは自動的にdeleteされず、誰がnewから出てきたオブジェクトがdeleteに落ちます.
ここまで来ると、強いポインタの分析が完了し、最後に弱いポインタを分析します.
        4. 弱ポインタ
弱いポインタで使用する参照カウントクラスは、強いポインタと同様にRefBaseクラスであるため、ここでは重複して説明する、frameworks/base/include/utils/RefBaseで定義された弱いポインタの実装に直接来る.hファイル内:
   
   
   
   
    
    
    
    
    
  1. template    
    2. 
    
    
    
    
  2. class wp   
    3. 
    
    
    
    
  3. {   
    4. 
    
    
    
    
  4. public:   
    5. 
    
    
    
    
  5.     typedef typename RefBase::weakref_type weakref_type;   
    6. 
    
    
    
    
  6.    
    7. 
    
    
    
    
  7.     inline wp() : m_ptr(0) { }   
    8. 
    
    
    
    
  8.    
    9. 
    
    
    
    
  9.     wp(T* other);   
    10. 
    
    
    
    
  10.     wp(const wp& other);   
    11. 
    
    
    
    
  11.     wp(const sp& other);   
    12. 
    
    
    
    
  12.     template wp(U* other);   
    13. 
    
    
    
    
  13.     template wp(const sp& other);   
    14. 
    
    
    
    
  14.     template wp(const wp& other);   
    15. 
    
    
    
    
  15.    
    16. 
    
    
    
    
  16.     ~wp();   
    17. 
    
    
    
    
  17.    
    18. 
    
    
    
    
  18.     // Assignment   
    19. 
    
    
    
    
  19.    
    20. 
    
    
    
    
  20.     wp& operator = (T* other);   
    21. 
    
    
    
    
  21.     wp& operator = (const wp& other);   
    22. 
    
    
    
    
  22.     wp& operator = (const sp& other);   
    23. 
    
    
    
    
  23.    
    24. 
    
    
    
    
  24.     template wp& operator = (U* other);   
    25. 
    
    
    
    
  25.     template wp& operator = (const wp& other);   
    26. 
    
    
    
    
  26.     template wp& operator = (const sp& other);   
    27. 
    
    
    
    
  27.    
    28. 
    
    
    
    
  28.     void set_object_and_refs(T* other, weakref_type* refs);   
    29. 
    
    
    
    
  29.    
    30. 
    
    
    
    
  30.     // promotion to sp   
    31. 
    
    
    
    
  31.    
    32. 
    
    
    
    
  32.     sp promote() const;   
    33. 
    
    
    
    
  33.    
    34. 
    
    
    
    
  34.     // Reset   
    35. 
    
    
    
    
  35.    
    36. 
    
    
    
    
  36.     void clear();   
    37. 
    
    
    
    
  37.    
    38. 
    
    
    
    
  38.     // Accessors   
    39. 
    
    
    
    
  39.    
    40. 
    
    
    
    
  40.     inline  weakref_type* get_refs() const { return m_refs; }   
    41. 
    
    
    
    
  41.    
    42. 
    
    
    
    
  42.     inline  T* unsafe_get() const { return m_ptr; }   
    43. 
    
    
    
    
  43.    
    44. 
    
    
    
    
  44.     // Operators   
    45. 
    
    
    
    
  45.    
    46. 
    
    
    
    
  46.     COMPARE_WEAK(==)   
    47. 
    
    
    
    
  47.         COMPARE_WEAK(!=)   
    48. 
    
    
    
    
  48.         COMPARE_WEAK(>)   
    49. 
    
    
    
    
  49.         COMPARE_WEAK(
    50. 
    
    
    
    
  50.         COMPARE_WEAK(<=)   
    51. 
    
    
    
    
  51.         COMPARE_WEAK(>=)   
    52. 
    
    
    
    
  52.    
    53. 
    
    
    
    
  53.         inline bool operator == (const wp& o) const {   
    54. 
    
    
    
    
  54.             return (m_ptr == o.m_ptr) && (m_refs == o.m_refs);   
    55. 
    
    
    
    
  55.     }   
    56. 
    
    
    
    
  56.     template   
    57. 
    
    
    
    
  57.     inline bool operator == (const wp& o) const {   
    58. 
    
    
    
    
  58.         return m_ptr == o.m_ptr;   
    59. 
    
    
    
    
  59.     }   
    60. 
    
    
    
    
  60.    
    61. 
    
    
    
    
  61.     inline bool operator > (const wp& o) const {   
    62. 
    
    
    
    
  62.         return (m_ptr == o.m_ptr) ? (m_refs > o.m_refs) : (m_ptr > o.m_ptr);   
    63. 
    
    
    
    
  63.     }   
    64. 
    
    
    
    
  64.     template   
    65. 
    
    
    
    
  65.     inline bool operator > (const wp& o) const {   
    66. 
    
    
    
    
  66.         return (m_ptr == o.m_ptr) ? (m_refs > o.m_refs) : (m_ptr > o.m_ptr);   
    67. 
    
    
    
    
  67.     }   
    68. 
    
    
    
    
  68.    
    69. 
    
    
    
    
  69.     inline bool operator & o) const {   
    70. 
    
    
    
    
  70.         return (m_ptr == o.m_ptr) ? (m_refs 
    71. 
    
    
    
    
  71.     }   
    72. 
    
    
    
    
  72.     template   
    73. 
    
    
    
    
  73.     inline bool operator & o) const {   
    74. 
    
    
    
    
  74.         return (m_ptr == o.m_ptr) ? (m_refs 
    75. 
    
    
    
    
  75.     }   
    76. 
    
    
    
    
  76.     inline bool operator != (const wp& o) const { return m_refs != o.m_refs; }   
    77. 
    
    
    
    
  77.     template inline bool operator != (const wp& o) const { return !operator == (o); }   
    78. 
    
    
    
    
  78.     inline bool operator <= (const wp& o) const { return !operator > (o); }   
    79. 
    
    
    
    
  79.     template inline bool operator <= (const wp& o) const { return !operator > (o); }   
    80. 
    
    
    
    
  80.     inline bool operator >= (const wp& o) const { return !operator 
    81. 
    
    
    
    
  81.     template inline bool operator >= (const wp& o) const { return !operator 
    82. 
    
    
    
    
  82.    
    83. 
    
    
    
    
  83. private:   
    84. 
    
    
    
    
  84.     template friend class sp;   
    85. 
    
    
    
    
  85.     template friend class wp;   
    86. 
    
    
    
    
  86.    
    87. 
    
    
    
    
  87.     T*              m_ptr;   
    88. 
    
    
    
    
  88.     weakref_type*   m_refs;   
    89. 
    
    
    
    
  89. };   
    90.

強いポインタクラスに比べて、メンバー変数m_が1つあります.ptrはターゲットオブジェクトを指しますが、弱いポインタには追加のメンバー変数m_があります.refs、そのタイプはweakref_typeポインタ、次に弱いポインタの構造関数を分析したとき、初期化された場合を見てみましょう.ここで注目すべきは,依然として弱いポインタの構造関数と構造関数である.
まず、コンストラクション関数を見てみましょう.
   
   
   
   
    
    
    
    
    
  1. template   
    2. 
    
    
    
    
  2. wp::wp(T* other)   
    3. 
    
    
    
    
  3.     : m_ptr(other)   
    4. 
    
    
    
    
  4. {   
    5. 
    
    
    
    
  5.     if (other) m_refs = other->createWeak(this);   
    6. 
    
    
    
    
  6. }   
    7.

ここでのパラメータotherは必ずRefBaseクラスを継承するので、ここではframeworks/base/libs/utils/RefBaseで定義RefBaseクラスのcreateWeak関数を呼び出す.cppファイル:
   
   
   
   
    
    
    
    
    
  1. RefBase::weakref_type* RefBase::createWeak(const void* id) const   
    2. 
    
    
    
    
  2. {   
    3. 
    
    
    
    
  3.     mRefs->incWeak(id);   
    4. 
    
    
    
    
  4.     return mRefs;   
    5. 
    
    
    
    
  5. }   
    6.

ここでのメンバー変数mRefsのタイプはweakref_implポインタ、weakref_implクラスのincWeak関数は、オブジェクトの弱い参照数を増やす役割を果たしています.関数は最後にmRefsを返し、弱いポインタオブジェクトのメンバー変数m_refsはターゲットオブジェクトを指すweakref_implオブジェクトです.
構造関数を見てみましょう.
   
   
   
   
    
    
    
    
    
  1. template   
    2. 
    
    
    
    
  2. wp::~wp()   
    3. 
    
    
    
    
  3. {   
    4. 
    
    
    
    
  4.     if (m_ptr) m_refs->decWeak(this);   
    5. 
    
    
    
    
  5. }   
    6.

ここで、弱いポインタは、解析時に強いポインタとは異なり、ターゲットオブジェクトのweakref_を直接呼び出すimplオブジェクトのdecWeak関数により弱参照カウントが減少し、弱参照カウントが0の場合、ターゲットオブジェクトでのフラグビット(0、OBJECT_LIFETIME_WEAKまたはOBJECT_LIFETIME_FOREVER)に基づいてdeleteターゲットオブジェクトを決定しますが、前述したように、ここでは説明しません.
 
ここまで分析して、弱いポインタはまだ紹介していないで、その最も重要な特性は私達はまだ分析していません.前述したように、弱いポインタの最大の特徴は、ターゲットオブジェクトを直接操作できないことです.これはどのようにして行われていますか.秘密は、弱いポインタクラスに*と->操作記号が再ロードされず、強いポインタにはこの2つの操作記号が再ロードされていることです.しかし、ターゲットオブジェクトを操作するには、どうすればいいのでしょうか.弱いポインタを強いポインタにアップグレードします.
   
   
   
   
    
    
    
    
    
  1. template   
    2. 
    
    
    
    
  2. sp wp::promote() const   
    3. 
    
    
    
    
  3. {   
    4. 
    
    
    
    
  4.     return sp(m_ptr, m_refs);   
    5. 
    
    
    
    
  5. }   
    6.

メンバー変数m_を使用してアップグレードptrとm_refsは強いポインタspを構築し,ここでm_ptrはターゲットオブジェクトを指すポインタであり、m_refsはターゲットオブジェクトの中を指すweakref_implオブジェクト.
この強いポインタの構造過程を見てみましょう.
   
   
   
   
    
    
    
    
    
  1. template   
    2. 
    
    
    
    
  2. sp::sp(T* p, weakref_type* refs)   
    3. 
    
    
    
    
  3.     : m_ptr((p && refs->attemptIncStrong(this)) ? p : 0)   
    4. 
    
    
    
    
  4. {   
    5. 
    
    
    
    
  5. }   
    6.

主に、ターゲットオブジェクトを指すメンバー変数m_を初期化します.ptr、ターゲットオブジェクトがまだ存在する場合、このm_ptrはターゲットオブジェクトを指し、ターゲットオブジェクトが存在しない場合、m_ptrはNULLです.アップグレードが成功するかどうかは、refs->attemptIncStrong関数の戻り結果によって決まります.
   
   
   
   
    
    
    
    
    
  1. bool RefBase::weakref_type::attemptIncStrong(const void* id)   
    2. 
    
    
    
    
  2. {   
    3. 
    
    
    
    
  3.     incWeak(id);   
    4. 
    
    
    
    
  4.    
    5. 
    
    
    
    
  5.     weakref_impl* const impl = static_cast(this);   
    6. 
    
    
    
    
  6.    
    7. 
    
    
    
    
  7.     int32_t curCount = impl->mStrong;   
    8. 
    
    
    
    
  8.     LOG_ASSERT(curCount >= 0, "attemptIncStrong called on %p after underflow",   
    9. 
    
    
    
    
  9.         this);   
    10. 
    
    
    
    
  10.     while (curCount > 0 && curCount != INITIAL_STRONG_VALUE) {   
    11. 
    
    
    
    
  11.         if (android_atomic_cmpxchg(curCount, curCount+1, &impl->mStrong) == 0) {   
    12. 
    
    
    
    
  12.             break;   
    13. 
    
    
    
    
  13.         }   
    14. 
    
    
    
    
  14.         curCount = impl->mStrong;   
    15. 
    
    
    
    
  15.     }   
    16. 
    
    
    
    
  16.    
    17. 
    
    
    
    
  17.     if (curCount <= 0 || curCount == INITIAL_STRONG_VALUE) {   
    18. 
    
    
    
    
  18.         bool allow;   
    19. 
    
    
    
    
  19.         if (curCount == INITIAL_STRONG_VALUE) {   
    20. 
    
    
    
    
  20.             // Attempting to acquire first strong reference...  this is allowed   
    21. 
    
    
    
    
  21.             // if the object does NOT have a longer lifetime (meaning the   
    22. 
    
    
    
    
  22.             // implementation doesn't need to see this), or if the implementation   
    23. 
    
    
    
    
  23.             // allows it to happen.   
    24. 
    
    
    
    
  24.             allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK   
    25. 
    
    
    
    
  25.                 || impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);   
    26. 
    
    
    
    
  26.         } else {   
    27. 
    
    
    
    
  27.             // Attempting to revive the object...  this is allowed   
    28. 
    
    
    
    
  28.             // if the object DOES have a longer lifetime (so we can safely   
    29. 
    
    
    
    
  29.             // call the object with only a weak ref) and the implementation   
    30. 
    
    
    
    
  30.             // allows it to happen.   
    31. 
    
    
    
    
  31.             allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_WEAK   
    32. 
    
    
    
    
  32.                 && impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);   
    33. 
    
    
    
    
  33.         }   
    34. 
    
    
    
    
  34.         if (!allow) {   
    35. 
    
    
    
    
  35.             decWeak(id);   
    36. 
    
    
    
    
  36.             return false;   
    37. 
    
    
    
    
  37.         }   
    38. 
    
    
    
    
  38.         curCount = android_atomic_inc(&impl->mStrong);   
    39. 
    
    
    
    
  39.    
    40. 
    
    
    
    
  40.         // If the strong reference count has already been incremented by   
    41. 
    
    
    
    
  41.         // someone else, the implementor of onIncStrongAttempted() is holding   
    42. 
    
    
    
    
  42.         // an unneeded reference.  So call onLastStrongRef() here to remove it.   
    43. 
    
    
    
    
  43.         // (No, this is not pretty.)  Note that we MUST NOT do this if we   
    44. 
    
    
    
    
  44.         // are in fact acquiring the first reference.   
    45. 
    
    
    
    
  45.         if (curCount > 0 && curCount 
    46. 
    
    
    
    
  46.             impl->mBase->onLastStrongRef(id);   
    47. 
    
    
    
    
  47.         }   
    48. 
    
    
    
    
  48.     }   
    49. 
    
    
    
    
  49.    
    50. 
    
    
    
    
  50.     impl->addWeakRef(id);   
    51. 
    
    
    
    
  51.     impl->addStrongRef(id);   
    52. 
    
    
    
    
  52.    
    53. 
    
    
    
    
  53. #if PRINT_REFS   
    54. 
    
    
    
    
  54.     LOGD("attemptIncStrong of %p from %p: cnt=%d
    "    , this, id, curCount);   
    55. 
    
    
    
    
  55. #endif   
    56. 
    
    
    
    
  56.    
    57. 
    
    
    
    
  57.     if (curCount == INITIAL_STRONG_VALUE) {   
    58. 
    
    
    
    
  58.         android_atomic_add(-INITIAL_STRONG_VALUE, &impl->mStrong);   
    59. 
    
    
    
    
  59.         impl->mBase->onFirstRef();   
    60. 
    
    
    
    
  60.     }   
    61. 
    
    
    
    
  61.    
    62. 
    
    
    
    
  62.     return true;   
    63. 
    
    
    
    
  63. }   
    64.

この関数の役割は、ターゲットオブジェクトの強い参照カウントを増やそうとすることですが、失敗する可能性があります.失敗した原因は、ターゲットオブジェクトがdeleteによって削除されたか、または他の原因である可能性があります.以下で分析します.先に強いポインタについて説明したように、ターゲットオブジェクトの強い参照カウントを増やすと同時に、ターゲットオブジェクトの弱い参照カウントも増加するので、関数は最初にincWeak関数を呼び出してターゲットオブジェクトの参照カウントを先に増加させ、後でターゲットオブジェクトの強い参照カウントを増加しようとすると失敗した場合、decWeak関数が呼び出され、前のincWeak操作がロールバックされます.
ここで、ターゲットオブジェクトの強い参照カウントを増やそうとすると、ターゲットオブジェクトが他の強いポインタで参照されている場合、すなわち、その強い参照カウントが0より大きく、INITIAL_に等しくない場合に分けて議論される.STRONG_VALUE、もう1つのケースは、ターゲットオブジェクトが強いポインタで参照されていないことです.すなわち、その強い参照数が0以下、またはINITIAL_に等しいことです.STRONG_VALUE.
1つ目のケースは簡単です.この場合、ターゲットオブジェクトが必ず存在することを示すので、この弱いポインタを強いポインタに引き上げることができます.この場合、ターゲットオブジェクトの強い参照カウント値を簡単に増加すればいいです.
   
   
   
   
    
    
    
    
    
  1.    while (curCount > 0 && curCount != INITIAL_STRONG_VALUE) {   
    2. 
    
    
    
    
  2. if (android_atomic_cmpxchg(curCount, curCount+1, &impl->mStrong) == 0) {   
    3. 
    
    
    
    
  3.     break;   
    4. 
    
    
    
    
  4. }   
    5. 
    
    
    
    
  5. curCount = impl->mStrong;   
    6. 
    
    
    
    
  6.    }   
    7.

ここでターゲットオブジェクトの強い参照カウントに対してプラス1操作を実行する場合、原子性を保証するには、他の場所でもこのターゲットオブジェクトの強い参照カウントにプラス1操作を実行している可能性があるため、android_を呼び出すのが一般的です.atomic_inc関数は完了しますが、ここではandroid_を呼び出すことによってatomic_cmpxchg関数で完了、android_atomic_cmpxchg関数はアーキテクチャに関連する関数であり、いくつかの特殊な命令を提供するアーキテクチャ上でandroid_を呼び出す.atomic_cmpxchg関数はandroidを呼び出すよりも1を加算する操作を実行する効率が高い.atomic_inc関数はもっと高いです.関数android_atomic_cmpxchgはsystem/core/include/cutils/atomicである.hファイルで定義されたマクロ:
   
   
   
   
    
    
    
    
    
  1. int android_atomic_release_cas(int32_t oldvalue, int32_t newvalue,   
    2. 
    
    
    
    
  2.         volatile int32_t* addr);   
    3. 
    
    
    
    
  3.    
    4. 
    
    
    
    
  4. #define android_atomic_cmpxchg android_atomic_release_cas   
    5.

実際に実行される関数はandroidですatomic_release_cas、この関数の動作原理は大体こうです:もしそれが*addr==oldvalueを発見したら、*addr=newvalueの操作を実行して、それから0を返して、さもなくば何もしないで、1を返します.このシナリオでは、oldvalueはcurCountに等しく、newvalueはcurCount+1に等しく、*addr==oldvalueの条件下では、ターゲットオブジェクトに対する強い参照カウント値が1増加することに相当する.どんな場合*addr!=oldvalueは?androidを呼び出すatomic_release_cas関数の前にoldvalueと値はアドレスaddrから読み出され、android_を実行するとatomic_release_cas関数の場合、アドレスaddrを他の場所で操作すると*addrが現れる可能性があります!=oldvalueの場合、他の場所でもターゲットオブジェクトの強い参照カウントが操作されていることを示します.そのため、ここではターゲットオブジェクトの強い参照カウントを増やす操作は実行できません.ターゲットオブジェクトの強い参照カウントを他の場所で操作してから再実行する必要があります.これは、whileループによって実行される理由です.
 
2つ目のケースは複雑です.この場合、ターゲットオブジェクトがまだ存在するか、存在しない可能性があるので、実際の状況から判断します.ターゲットオブジェクトの強い参照カウント値がINITIAL_に等しい場合STRONG_VALUEは、このターゲットオブジェクトがまだ強いポインタで参照されていないことを示します.この場合、弱いポインタが強いポインタに昇格できる条件は、次のとおりです.
allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK  
    || impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);  
zabbixはホストとポートリストに基づいてリモートMongoDBインスタンスを自動的に検出監視する
Androidはjavaコードでユーザーのクリックと長押しをシミュレートします