前面的文章分析了OC類的結(jié)構(gòu)構(gòu)體實現(xiàn)，了解了objc_class結(jié)構(gòu)體中有幾個主要成員分別是isa、superclass、cache以及bits，今天就來分析一下cache成員的作用，以及如何實現(xiàn)的。

classstruct.png

@interface Person : NSObject
@property (nonatomic, copy) NSString *lgName;
@property (nonatomic, strong) NSString *nickName;
- (void)sayHello;
- (void)sayCode;
- (void)sayMaster;
- (void)sayXX;
+ (void)sayHappy;
@end

@implementation Person
- (void)sayHello{
    NSLog(@"Person say : %s",__func__);
}
- (void)sayCode{
    NSLog(@"Person say : %s",__func__);
}
- (void)sayMaster{
    NSLog(@"Person say : %s",__func__);
}
- (void)sayXX{
    NSLog(@"Person say : %s",__func__);
}
+ (void)sayHappy{
    NSLog(@"Person say : %s",__func__);
}
@end
//cache_t測試代碼
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        Person *p  = [Person alloc];
        Class pClass = [Person class];
        [p sayHello];
        [p sayCode];
        [p sayMaster];
        NSLog(@"%@",pClass);
    }
    return 0;
}

在[p sayHello];處打斷點，運行后在lldb窗口進(jìn)行打印調(diào)試：

classadress.png

struct objc_class : objc_object {
    // Class ISA;
    Class superclass;
    cache_t cache;             // formerly cache pointer and vtable
    class_data_bits_t bits; 
.......
}

還是用指針偏移的方式，找到cache_t cache;所在的內(nèi)存位置并打印出來。cache_t cache;之前有兩個成員分別是isa和superclass，各占8字節(jié)，所以cache_t cache;的位置就是類的首地址偏移16字節(jié)，對于十六進(jìn)制地址0x0000000100002298來說，就是倒數(shù)第二位加1，變成0x00000001000022a8，并把類型轉(zhuǎn)換為cache_t類型，打印可以看到：

(lldb) p (cache_t*)0x00000001000022a8
(cache_t *) $1 = 0x00000001000022a8

這樣就拿到了cache_t cache;成員的指針，那么想看其內(nèi)部的內(nèi)容就要先了解cache_t結(jié)構(gòu)體的實現(xiàn)，找到源碼打開看下：

struct cache_t {
#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_OUTLINED
    explicit_atomic<struct bucket_t *> _buckets;
    explicit_atomic<mask_t> _mask;
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
    explicit_atomic<uintptr_t> _maskAndBuckets;
    mask_t _mask_unused;
   ....省略
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4
   ....
    explicit_atomic<uintptr_t> _maskAndBuckets;
    mask_t _mask_unused;
....
#else
#error Unknown cache mask storage type.
#endif
    
#if __LP64__
    uint16_t _flags;
#endif
    uint16_t _occupied;
....
};

已經(jīng)省略了很多非關(guān)鍵代碼，可以看到cache_t的內(nèi)部是比較復(fù)雜的，如何來分析他的內(nèi)容呢，比較明顯的是這里面的幾個宏判斷：

#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_OUTLINED
....
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_HIGH_16
....
#elif CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_LOW_4
....
#else
#error Unknown cache mask storage type.
#endif

首先要確定我們的調(diào)試環(huán)境會走入那個分支，這個在我之前分析OC類的isa結(jié)構(gòu)的文章中已經(jīng)做過分析，這里就不在贅述，結(jié)論就是在MAC環(huán)境下調(diào)試會進(jìn)入第一個分支，也就是#if CACHE_MASK_STORAGE == CACHE_MASK_STORAGE_OUTLINED，有了這個結(jié)論結(jié)合源碼就可以知道此時我們只關(guān)心下面的兩個家伙就可以了：

explicit_atomic<struct bucket_t *> _buckets;
explicit_atomic<mask_t> _mask;

這兩個家伙看起來也不是什么好對付的，不過他們的聲明方式很像泛型都有一個<>來指定具體類型，前面也是相同的explicit_atomic類型，那就點擊explicit_atomic看下源碼：

template <typename T>
struct explicit_atomic : public std::atomic<T> {
    explicit explicit_atomic(T initial) noexcept : std::atomic<T>(std::move(initial)) {}
    operator T() const = delete;
    
    T load(std::memory_order order) const noexcept {
        return std::atomic<T>::load(order);
    }
    void store(T desired, std::memory_order order) noexcept {
        std::atomic<T>::store(desired, order);
    }
    
    // Convert a normal pointer to an atomic pointer. This is a
    // somewhat dodgy thing to do, but if the atomic type is lock
    // free and the same size as the non-atomic type, we know the
    // representations are the same, and the compiler generates good
    // code.
    static explicit_atomic<T> *from_pointer(T *ptr) {
        static_assert(sizeof(explicit_atomic<T> *) == sizeof(T *),
                      "Size of atomic must match size of original");
        explicit_atomic<T> *atomic = (explicit_atomic<T> *)ptr;
        ASSERT(atomic->is_lock_free());
        return atomic;
    }
};

果然第一行就是template <typename T>，很明顯是個泛型聲明，這個就是C++的模板，具體的類型還是由<>中的類型決定，除此之外explicit_atomic只是對泛型T進(jìn)行了方法聲明，并沒有其他的成員，所以對于整個explicit_atomic<struct bucket_t *> _buckets;來說，我們只關(guān)心struct bucket_t * _buckets就可以了，對于explicit_atomic<mask_t> _mask;也可以等價為mask_t _mask來看待。如果實在想弄明白explicit_atomic的作用，這里可以做一個簡單的解答，由于struct cache_t結(jié)構(gòu)體顧名思義是一個緩存，對于緩存來說就會有增刪改查，而對數(shù)據(jù)進(jìn)行增刪改查操作就會牽扯到線程安全，而atomic關(guān)鍵字就是線程安全的作用，所以explicit_atomic<T>結(jié)構(gòu)體聲明的數(shù)據(jù)類型代表著他的操作是線程安全的。由于本文的重點是研究cache_t緩存的工作機制，對于explicit_atomic<T>模板泛型是怎么實現(xiàn)的線程安全暫不展開。
下面再來看看另外一個重點分析的對象struct bucket_t * _buckets，看看他的源碼：

struct bucket_t {
private:
    // IMP-first is better for arm64e ptrauth and no worse for arm64.
    // SEL-first is better for armv7* and i386 and x86_64.
#if __arm64__
    explicit_atomic<uintptr_t> _imp;
    explicit_atomic<SEL> _sel;
#else
    explicit_atomic<SEL> _sel;
    explicit_atomic<uintptr_t> _imp;
#endif
............
};

同樣的道理，這里我們只關(guān)心uintptr_t _imp和SEL _sel就好了，而外面套著的explicit_atomic就是起到線程安全的作用，這個宏判斷#if __arm64__當(dāng)然是區(qū)分運行環(huán)境的，可以看到真機環(huán)境和非真機環(huán)境只是兩個成員的聲明順序不同。bucket本身是桶的意思，代表一個可以存放東西的工具，因此可以得知bucket_t就是存放方法實現(xiàn)_imp和方法編號SEL的地方。說完了bucket_t再回到struct cache_t中看看下一個成員mask_t _mask，mask顧名思義是面具的意思，之前分析isa的時候也有一個ISA_MASK，也就是掩碼，再往下跳出宏判斷還有兩個需要關(guān)注的成員，一個是uint16_t _flags;，另外一個是uint16_t _occupied;，這些成員就是我們分析cache_t緩存機制時需要重點分析的內(nèi)容：

dijinfenxi.png

//打印出cache_t的指針
(lldb) p (cache_t*)0x00000001000022a8
(cache_t *) $1 = 0x00000001000022a8
//打印cache_t指針內(nèi)容
(lldb) p *$1
(cache_t) $2 = {
  _buckets = {
    std::__1::atomic<bucket_t *> = 0x000000010032e410 {
      _sel = {
        std::__1::atomic<objc_selector *> = (null)
      }
      _imp = {
        std::__1::atomic<unsigned long> = 0
      }
    }
  }
  _mask = {
    std::__1::atomic<unsigned int> = 0
  }
  _flags = 32804
  _occupied = 0
}
(lldb) 

可以看到，直接p *$1，也就是cache_t的指針，可以直接打印出cache_t的內(nèi)容，可以清晰的看到里面有_buckets，它的內(nèi)部還有_sel和_imp，還有_mask、_flags以及_occupied，下面就要有一些處理，看看最開始的代碼，還記得最初的斷點是在[p sayHello];這里，下面就讓[p sayHello];這里的斷點過一下，按照上面的方法在打印一次看看結(jié)果是否相同：

aftermethod.png

cannotprint.png

struct cache_t {
...........
public:
    static bucket_t *emptyBuckets();
    struct bucket_t *buckets();
..........
}

在public方法聲明中，有一個buckets()方法，返回bucket_t *類型，就來試試它能否拿到我們需要的_buckets成員：

buckets.png

struct bucket_t {
.............
public:
    inline SEL sel() const { return _sel.load(memory_order::memory_order_relaxed); }
    inline IMP imp(Class cls) const{
.............
}

接著打印p $7.sel()就拿到了方法名稱sayHello，再來試試打印imp(Class cls)方法：

impl.png

machoview.png