cache_t的结构

struct objc_class : objc_object {
    // Class ISA;  继承自objc_object  //8
    Class superclass;  //8
    cache_t cache;  //16           // formerly cache pointer and vtable
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags
   
    ...
}

在上一篇类的结构分析中， 我们从类的结构体源码中看到，类中存有一个cache_t cache(方法缓存)，但是没有做具体分体分析，这篇博客就来具体分析一下cache_t 。
先来看一下cache_t的源码结构：

struct cache_t {
    struct bucket_t *_buckets;
    mask_t _mask;
    mask_t _occupied;

public:
    struct bucket_t *buckets();
    mask_t mask();
    mask_t occupied();
    void incrementOccupied();
    void setBucketsAndMask(struct bucket_t *newBuckets, mask_t newMask);
    void initializeToEmpty();

    mask_t capacity();
    bool isConstantEmptyCache();
    bool canBeFreed();

    static size_t bytesForCapacity(uint32_t cap);
    static struct bucket_t * endMarker(struct bucket_t *b, uint32_t cap);

    void expand();
    void reallocate(mask_t oldCapacity, mask_t newCapacity);
    struct bucket_t * find(cache_key_t key, id receiver);

    static void bad_cache(id receiver, SEL sel, Class isa) __attribute__((noreturn));
};

_buckets: 一个存放bucket_t 结构体的数组，用来存放缓存方法的imp和缓存的key。
_mask：缓存数组的大小
_occupied：当前已缓存的方法数

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__
    MethodCacheIMP _imp;
    cache_key_t _key;
#else
    cache_key_t _key;
    MethodCacheIMP _imp;
#endif
...
};

using MethodCacheIMP = IMP;
typedef uintptr_t cache_key_t;

//获取key
cache_key_t getKey(SEL sel) 
{
    assert(sel);
    return (cache_key_t)sel;
}

_imp: 缓存的方法的imp。
_key: 有sel强转而来，其实就是SEL的内存地址。

了解完了cache_t的结构，我们通过代码来验证一下，实际的类中的cache_t是否如我们分析的一样呢？我们创建一个简单的person对象，然后调用一下它的sayHappy方法，然后进入断点调试：

image.png

在控制台做如下输出：

//打印person的类对象的内存地址
(lldb) x/4gx person.class
0x100002518: 0x001d8001000024f1 0x0000000100b37140
0x100002528: 0x0000000100fc4320 0x0000000300000003

//根据内存便宜找到cache_t并打印cache_t的指针
(lldb) p (cache_t *)0x100002528
(cache_t *) $1 = 0x0000000100002528

//打印cache_t
(lldb) p *$1
(cache_t) $2 = {
  _buckets = 0x0000000100fc4320
  _mask = 3
  _occupied = 3
}

//打印_buckets的指针
(lldb) p $2._buckets
(bucket_t *) $3 = 0x0000000100fc4320

//打印_buckets指针指向的地址，也就是_buckets的第一个元素。
(lldb) p *$3
(bucket_t) $4 = {
  _key = 4294974988
  _imp = 0x0000000100001a20 (LGTest`-[ZPerson sayHello] at main.m:124)
}

我们发现打印出的sayHello方法，正式在上面调用的[person sayHello]。说明cache_t里确实缓存了我们曾经调用过的方法。那么cache_t是如何进行方法的缓存的呢？请继续往下看。

cache_t的缓存查找

在cache_t的结构体里我们看到有这样一个方法：

struct bucket_t * find(cache_key_t key, id receiver);

点进去看它的具体实现：

bucket_t * cache_t::find(cache_key_t k, id receiver)
{
    assert(k != 0);
    //取出当前cache_t的buckets
    bucket_t *b = buckets();
    //取出当前cache_t的mask
    mask_t m = mask();
    // 通过cache_hash函数【begin  = k & m】计算出key值 k 对应的 index值 begin，用来记录查询起始索引
    mask_t begin = cache_hash(k, m);
    // begin 赋值给 i，用于切换索引
    mask_t i = begin;
    do {
        if (b[i].key() == 0  ||  b[i].key() == k) {
            //用这个i从散列表取值，如果取出来的bucket_t的 key = k，则查询成功，返回该bucket_t，
            //如果key = 0，说明在索引i的位置上还没有缓存过方法，同样需要返回该bucket_t，用于中止缓存查询。
            return &b[i];
        }
    } while ((i = cache_next(i, m)) != begin);
    
   //如果此时还没有找到key对应的bucket_t，或者是空的bucket_t，则循环结束，说明查找失败，调用bad_cache方法。
    Class cls = (Class)((uintptr_t)this - offsetof(objc_class, cache));
    cache_t::bad_cache(receiver, (SEL)k, cls);

这个方法的作用就是根据传进来的key遍历查找buckets，然后返回存有方法imp的bucket_t。这个方法应该属于查找流程中的一个过程。我们再在源码中全局搜索一下，是谁什么时候调用了这个方法。

我们在cache_fill_nolock方法中找到了find方法调用。先贴一下cache_fill_nolock方法的源码实现，在具体分析一下方法里具体干了啥。

static void cache_fill_nolock(Class cls, SEL sel, IMP imp, id receiver)
{
    cacheUpdateLock.assertLocked();

    // Never cache before +initialize is done
    if (!cls->isInitialized()) return;

    // Make sure the entry wasn't added to the cache by some other thread 
    // before we grabbed the cacheUpdateLock.
    if (cache_getImp(cls, sel)) return;

    cache_t *cache = getCache(cls);
    cache_key_t key = getKey(sel);

    // Use the cache as-is if it is less than 3/4 full
    mask_t newOccupied = cache->occupied() + 1;
    mask_t capacity = cache->capacity();
    if (cache->isConstantEmptyCache()) {
        // Cache is read-only. Replace it.
        cache->reallocate(capacity, capacity ?: INIT_CACHE_SIZE);
    }
    else if (newOccupied <= capacity / 4 * 3) {
        // Cache is less than 3/4 full. Use it as-is.
    }
    else {
        // Cache is too full. Expand it.
        cache->expand();
    }

    // Scan for the first unused slot and insert there.
    // There is guaranteed to be an empty slot because the 
    // minimum size is 4 and we resized at 3/4 full.
    bucket_t *bucket = cache->find(key, receiver);
    if (bucket->key() == 0) cache->incrementOccupied();
    bucket->set(key, imp);
}

1、cache_fill_nolock方法传进来4个参数：类cls、方法的sel、方法的imp和方法的调用者。
2、加一把cacheUpdateLock。
3、然后进行一下安全检查。
4、取出cls中的cahce。
5、根据sel生成相对应的key。
6、取出当前cache缓存方法的个数，然后加1，得到newOccupied，新的缓存方法个数。
7、得到当前cache的最大容量。
8、进行总容量与缓存个数的判断：
a.当前cache里面是空的，调用reallocate开去开辟新的buckets赋值的当前的cache_t
b.当前缓存个数小于总容量的3/4，不做操作
c.当前缓存个数不小于总容量的3/4，就调用expand()去扩容。
9、调用cache的find方法查找缓存
10、如果没找到，将已缓存的数目occupied加1，再将key和imp存入bucket

关于expand()扩容方法，我们在看一下它的实现源码：

void cache_t::expand()
{
    cacheUpdateLock.assertLocked();
    
    uint32_t oldCapacity = capacity();
    uint32_t newCapacity = oldCapacity ? oldCapacity*2 : INIT_CACHE_SIZE;

    if ((uint32_t)(mask_t)newCapacity != newCapacity) {
        // mask overflow - can't grow further
        // fixme this wastes one bit of mask
        newCapacity = oldCapacity;
    }

    reallocate(oldCapacity, newCapacity);
}

我们可以看到，方法中先去取了一下旧的容量大小oldCapacity，然后将oldCapacity乘以2，也就是将oldCapacity扩大了一倍，得到新的容量大小newCapacity。在调用reallocate()去进行内存的开辟，需要将oldCapacity和newCapacity作为参数传递进去。
我们再看一下reallocate()方法的源码：

{
    bool freeOld = canBeFreed();
      
    //获取原来的buckets
    bucket_t *oldBuckets = buckets();
    //根据新的容量大小，创新出新的newBuckets，这个newBuckets是空的
    bucket_t *newBuckets = allocateBuckets(newCapacity);

    assert(newCapacity > 0);
    assert((uintptr_t)(mask_t)(newCapacity-1) == newCapacity-1);
   
    //将新的newCapacity-1作为新的mask大小，再将_buckets和mask存入cache_t，并将occupied置为0
    setBucketsAndMask(newBuckets, newCapacity - 1);
    //将旧的buckets释放
    if (freeOld) {
        cache_collect_free(oldBuckets, oldCapacity);
        cache_collect(false);
    }
}

根据上面源码的注释，我们可以知道reallocate()方法具体做了哪些操作。然后我们再看一下系统都在哪些方法调用了reallocate()。根据全局搜索可以找到，有两处代码进行了reallocate()方法的调用。一个是cache_t为空，第一次开辟的时候，再有就就是调用expand()方法进行扩容的时候。

image.png

关于cache_fill_nolock我们已经分析的差不多了。接下来我们再找找哪里调用了cache_fill_nolock，自下而上的查找一下，尽量到刨根儿，哈哈。

void cache_fill(Class cls, SEL sel, IMP imp, id receiver)
{
#if !DEBUG_TASK_THREADS
    mutex_locker_t lock(cacheUpdateLock);
    cache_fill_nolock(cls, sel, imp, receiver);
#else
    _collecting_in_critical();
    return;
#endif
}

找到cache_fill方法调用了cache_fill_nolock。再继续查找，找到lookUpImpOrForward，lookupMethodInClassAndLoadCache两个方法。根据方法名可以知道，当进行方法调用的时候，会进行cache_filll，也就是填充方法缓存。关于方法的调用，我们后面的博客再将。关于cache_t的分析基本上就是这些了。最后附上一张流程图，方便理清思路。

cache_t流程图.png