• 引用计数器的存储

    在64bit中，引用计数可以直接存储在优化过的isa指针中，也可能存储在SideTable类中。

    1. //refcnts是一个存放着对象引用计数的散列表
    2. typedef objc::DenseMap<DisguisedPtr<objc_object>,size_t,true> RefcountMap;
    4. /**
    5.  * The global weak references table. Stores object ids as keys,
    6.  * and weak_entry_t structs as their values.
    7.  */
    8. struct weak_table_t {
    9.     weak_entry_t *weak_entries;
    10.     size_t    num_entries;
    11.     uintptr_t mask;
    12.     uintptr_t max_hash_displacement;
    13. };
    15. struct SideTable {
    16.     spinlock_t slock;
    17.     RefcountMap refcnts;
    18.     weak_table_t weak_table;
    20.     SideTable() {
    21.         memset(&weak_table, 0, sizeof(weak_table));
    22.     }
    24.     ~SideTable() {
    25.         _objc_fatal("Do not delete SideTable.");
    26.     }
    27. };

    引用计数器的计算

    1. inline uintptr_t 
    2. objc_object::rootRetainCount()
    3. {
    4.     if (isTaggedPointer()) return (uintptr_t)this;
    6.     sidetable_lock();
    7.     isa_t bits = LoadExclusive(&isa.bits);
    8.     ClearExclusive(&isa.bits);
    9.     if (bits.nonpointer) { //优化过的isa指针
    10.         uintptr_t rc = 1 + bits.extra_rc;
    11.         if (bits.has_sidetable_rc) {  //引用计数器不是存储在isa中，而是存储在sidetable中
    12.             rc += sidetable_getExtraRC_nolock();
    13.         }
    14.         sidetable_unlock();
    15.         return rc;
    16.     }
    18.     sidetable_unlock();
    19.     return sidetable_retainCount();
    20. }
    22. size_t 
    23. objc_object::sidetable_getExtraRC_nolock()
    24. {
    25.     assert(isa.nonpointer);
    26.     SideTable& table = SideTables()[this];
    27.     RefcountMap::iterator it = table.refcnts.find(this); //通过this这个key取出对象的引用计数
    28.     if (it == table.refcnts.end()) return 0;
    29.     else return it->second >> SIDE_TABLE_RC_SHIFT;
    30. }
    32. ALWAYS_INLINE bool 
    33. objc_object::rootRelease(bool performDealloc, bool handleUnderflow)
    34. {
    35.     if (isTaggedPointer()) return false;
    37.     bool sideTableLocked = false;
    39.     isa_t oldisa;
    40.     isa_t newisa;
    42.  retry:
    43.     do {
    44.         oldisa = LoadExclusive(&isa.bits);
    45.         newisa = oldisa;
    46.         if (slowpath(!newisa.nonpointer)) {
    47.             ClearExclusive(&isa.bits);
    48.             //调用sidetable释放。
    49.             if (sideTableLocked) sidetable_unlock();
    50.         }
    51.         // don't check newisa.fast_rr; we already called any RR overrides
    52.         uintptr_t carry;
    53.         newisa.bits = subc(newisa.bits, RC_ONE, 0, &carry);  // extra_rc--
    54.         if (slowpath(carry)) {
    55.             // don't ClearExclusive()
    56.             goto underflow;
    57.         }
    58.     } while (slowpath(!StoreReleaseExclusive(&isa.bits, 
    59.                                              oldisa.bits, newisa.bits)));
    61.     if (slowpath(sideTableLocked)) sidetable_unlock();
    62.     return false;
    63. }
    65. uintptr_t
    66. objc_object::sidetable_release(bool performDealloc)
    67. {
    68. #if SUPPORT_NONPOINTER_ISA
    69.     assert(!isa.nonpointer);
    70. #endif
    71.     SideTable& table = SideTables()[this];
    73.     bool do_dealloc = false;
    75.     table.lock();
    76.     RefcountMap::iterator it = table.refcnts.find(this);
    77.     if (it == table.refcnts.end()) {
    78.         do_dealloc = true;
    79.         table.refcnts[this] = SIDE_TABLE_DEALLOCATING;
    80.     } else if (it->second < SIDE_TABLE_DEALLOCATING) {
    81.         // SIDE_TABLE_WEAKLY_REFERENCED may be set. Don't change it.
    82.         do_dealloc = true;
    83.         it->second |= SIDE_TABLE_DEALLOCATING;
    84.     } else if (! (it->second & SIDE_TABLE_RC_PINNED)) {
    85.         it->second -= SIDE_TABLE_RC_ONE;
    86.     }
    87.     table.unlock();
    88.     //到了一定的条件执行dealloc
    89.     if (do_dealloc  &&  performDealloc) {
    90.         ((void(*)(objc_object *, SEL))objc_msgSend)(this, SEL_dealloc);
    91.     }
    92.     return do_dealloc;
    93. }
    • ARC帮我们做了什么？

    ARC是LLVM编译器和Runtime系统相互协作的结果，利用编译器自动帮我们生成内存管理相关的代码，在程序运行的过程中又帮我们处理弱引用(weak)这种操作。