1.准备工作

  • 我的运转环境
    • macOS 13.1
    • M1 芯片
    • Xcode 14.0.1
  • 首要准备好一份源码，链接地址：github.com/LGCooci/KCO… ，我运用的是 objc4-866.9，初度运转报错如下：

iOS底层二刷第一课alloc的流程分析
__dyld_get_dlopen_image_header 和__dyld_objc_register_callbacks报错。
解决办法：分别搜一下这两个办法改成如下

iOS底层二刷第一课alloc的流程分析

iOS底层二刷第一课alloc的流程分析

clean一下，再运转就成功了。不过偶然也报错，可是再clean一次就能够了。

2.从alloc下手

 LGPerson *p = [LGPerson alloc];
 LGPerson * p1 = [p init];
 LGPerson * p2 = [p init];
 NSLog(@"目标p：%@，p的指针：%p",p,&p);
 NSLog(@"目标p1：%@，p1的指针：%p",p1,&p1);
 NSLog(@"目标p2：%@，p2的指针：%p",p2,&p2);

输出：

目标p ：<LGPerson: 0x600000c0c000>，p的指针： 0x30410b230
目标p1：<LGPerson: 0x600000c0c000>，p1的指针：0x30410b220
目标p2：<LGPerson: 0x600000c0c000>，p2的指针：0x30410b228

从输出来看p，p1，p2指向的是一个目标，也便是同一片内存，可是p，p1，p2自身是不同的。

iOS底层二刷第一课alloc的流程分析

alloc办法拓荒了一块内存空间，下面的init办法相当于又创建了几个指针来指向这块内存。可是他们详细做了什么操作，需求进一步的探求源码，一探终究。

3.探求源码的办法

跟着KC学习到了探求源码的三种办法。

  • 运用Control+Step Into进行调试
  • 经过汇编检查调用流程
  • 经过已知符号来探索详细调用

经过这三种办法都能够找到最终的libobjc.A.dylib-objc_alloc

4.alloc的详细探求

打开咱们准备好的objc4-866.9，然后运转代码跟着流程和调用来看看一个alloc下面究竟藏了多少办法。

4.1 alloc的完成办法

跟着源码，点击进入到alloc的完成：

+ (id)alloc {
  return _objc_rootAlloc(self);
}
id
_objc_rootAlloc(Class cls)
{
  return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}

调用流程alloc->_objc_rootAlloc->callAlloc，而callAlloc的完成就相对比较复杂了。

// Call [cls alloc] or [cls allocWithZone:nil], with appropriate
// shortcutting optimizations.
static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
  if (slowpath(checkNil && !cls)) return nil;
  if (fastpath(!cls->ISA()->hasCustomAWZ())) {
    return _objc_rootAllocWithZone(cls, nil);
  }
  // No shortcuts available.
  if (allocWithZone) {
    return ((id(*)(id, SEL, struct _NSZone *))objc_msgSend)(cls, @selector(allocWithZone:), nil);
  }
  return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));
}

这里呈现了几个比较重要的判别和办法：

1、slowpath和fastpath

这是宏界说

// 表明x的值为假的可能性更大
#define slowpath(x) (__builtin_expect(bool(x), 0))
// 表明x的值为真的可能性更大
#define fastpath(x) (__builtin_expect(bool(x), 1))

__builtin_expect是GCC提供给程序员运用，目的是将“分支转移”的信息提供给编译器，这样编译器能够对代码进行优化，以削减指令跳转带来的性能下降。

if (slowpath(checkNil && !cls))的意思便是cls大概率是有值的，告诉编译器编译时优化掉这个部分，也便是nil这个部分简直不会走，那么就直接来到了判别 if (fastpath(!cls->ISA()->hasCustomAWZ()))的部分。

2、hasCustomAWZ

它的完成如下：

bool hasCustomAWZ() const {
    return !cache.getBit(FAST_CACHE_HAS_DEFAULT_AWZ);
}

而FAST_CACHE_HAS_DEFAULT_AWZ的描绘是：

// class or superclass has default alloc/allocWithZone: implementation
// Note this is is stored in the metaclass.
#define FAST_CACHE_HAS_DEFAULT_AWZ (1<<14)

它是判别这个类或许它的父类有没有完成allocWithZone的，而办法hasCustomAWZ大概率全称是hasCustomAllocWithZone后边AllocWithZone缩写成了AWZ。

而类自身是有懒加载的概念的，第一次给这个类发送音讯之前，该类是没有加载的，所以收到alloc音讯的时分，那么allocWithZone是没有默认完成的，所以hasCustomAWZ回来false，会走流程_objc_rootAllocWithZone

第一次进到该办法：

iOS底层二刷第一课alloc的流程分析

而办法_objc_rootAllocWithZone的详细完成接着看下面。

3、_objc_rootAllocWithZone

id
_objc_rootAllocWithZone(Class cls, objc_zone_t zone __unused)
{
  // allocWithZone under __OBJC2__ ignores the zone parameter
    return _class_createInstanceFromZone(cls, 0, nil,
                    OBJECT_CONSTRUCT_CALL_BADALLOC);
}

调用了_class_createInstanceFromZone，这个办法就内容挺长的还挺多的，下面来侧重的看一下。

4.2 class_createInstanceFromZone办法拓荒空间

iOS底层二刷第一课alloc的流程分析

  • hasCxxCtor() 和 hasCxxDtor()

hasCxxCtor和hasCxxDtor是用来处理C++成员变量的构造和析构。

hasCxxCtor是判别当时class或许superclass是否有.cxx_construct的完成；

hasCxxDtor是判别当时class或许superclass是否有.cxx_destruct的完成。

// class or superclass has .cxx_construct/.cxx_destruct implementation
// FAST_CACHE_HAS_CXX_DTOR is chosen to alias with isa_t::has_cxx_dtor
#define FAST_CACHE_HAS_CXX_CTOR    (1<<1)
bool hasCxxCtor() {
    ASSERT(isRealized());
    return cache.getBit(FAST_CACHE_HAS_CXX_CTOR);
}
  • instanceSize()
//extraBytes 传进来是0
inline size_t instanceSize(size_t extraBytes) const {
    if(fastpath(cache.hasFastInstanceSize(extraBytes))) {
        return cache.fastInstanceSize(extraBytes);
    }
    size_t size = alignedInstanceSize() + extraBytes;
    // CF requires all objects be at least 16 bytes.
    //至少16个字节！！！！！！！！！！！！！！！！！！！！！
  if(size < 16) size = 16;
  return size;
}
uint32_t alignedInstanceSize() const {
    return word_align(unalignedInstanceSize());
}
static inline uint32_t word_align(uint32_t x) {
 return (x + WORD_MASK) & ~WORD_MASK;
}
#ifdef __LP64__
#define WORD_SHIFT 3UL
#define WORD_MASK 7UL
#define WORD_BITS 64
#else
#define WORD_SHIFT 2UL
#define WORD_MASK 3UL
#define WORD_BITS 32
#endif

在调用办法instanceSize传进来的参数extraBytes是0； hasFastInstanceSize在64位下才启用；

alignedInstanceSize是对齐办法，依据代码能够看到64位下是8字节对齐，32位下是4字节对齐，核算办法是对WORD_MASK取反，然后进行与的操作。所以这个办法核算了需求拓荒的空间巨细。

咱们回到办法_class_createInstanceFromZone中，zone这个值传进来的是nil，所以下面走的办法是 obj = (id)calloc(1, size); 而实践去开空间的操作是在calloc，它的详细完成在libmalloc中，它拓荒了内存空间，而且回来了一个指向该内存地址的指针。

4.3 initInstanceIsa 将类和isa指针关联

上面的instanceSize和calloc完成了空间的核算和拓荒，接下来履行来到

if(!zone && fast) {
    obj->initInstanceIsa(cls, hasCxxDtor);
} else {
    // Use raw pointer isa on the assumption that they might be
    // doing something weird with the zone or RR.
  obj->initIsa(cls);
 }

zone是nil，fast是是否能够创建Nonpointer的回来。会来到办法initInstanceIsa。

inline void
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
  ASSERT(!cls->instancesRequireRawIsa());
  ASSERT(hasCxxDtor == cls->hasCxxDtor());
  initIsa(cls, true, hasCxxDtor);
}

首要调用办法initIsa。

  • initIsa
inline void
objc_object::initIsa(Class cls, bool nonpointer, UNUSED_WITHOUT_INDEXED_ISA_AND_DTOR_BIT bool hasCxxDtor)
{
  isa_t newisa(0);
    // nonpointer:ture
  if (!nonpointer) {
    newisa.setClass(cls, this);
  } else {
    newisa.bits = ISA_MAGIC_VALUE;
    newisa.setClass(cls, **this**);
    newisa.extra_rc = 1;
    }
  isa() = newisa;
}

从办法initInstanceIsa传进来的第二个参数nonpointer是ture，所以走流程 else。

SUPPORT_INDEXED_ISA不同的架构下处理不同。64位下的直接走else的部分。走setClass。该办法要害代码：

inline void
isa_t::setClass(Class newCls, UNUSED_WITHOUT_PTRAUTH objc_object *obj)
{
    shiftcls = (uintptr_t)newCls >> 3;
}

该办法其实便是初始化一个isa_t然后绑定指向给cls。至于右移3位，因为是八字节对齐，指针后三位是无用的0，0与上任何都是0，估计是为了省内存削减耗费吧。

5. alloc的流程图

iOS底层二刷第一课alloc的流程分析

6. init 和 new

看过了上面alloc的流程，也简略看一下咱们常用的init还有new。

6.1 init

进行断点调试，咱们找到办法_objc_rootInit

iOS底层二刷第一课alloc的流程分析
它的完成：

id
_objc_rootInit(id obj)
{
  // In practice, it will be hard to rely on this function.
  // Many classes do not properly chain -init calls.
  return obj;
}

嗯，传进来啥，回来啥。

6.2 new

相同的，new的实践完成办法是objc_opt_new。它的完成：

id
objc_opt_new(Class cls)
{
  if (fastpath(cls && !cls->ISA()->hasCustomCore())) {
    return [callAlloc(cls, false/checkNil/) init];
  }
  return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(new));
}

要害代码是[callAlloc(cls, false/checkNil/) init]，实践上也是调用的 [alloc init] 。

7.总结

alloc的首要流程：

  1. 类没有被加载进来时，也便是没有完成allocWithZone办法时，那么再发送一遍alloc音讯，直到已经allocWithZone了，保证已经被加载进来。
  2. 经过instanceSize核算需求的空间。
  3. calloc拓荒实践的空间。
  4. initInstanceIsa将class与isa进行关联。
  • init 实质回来传入的self目标
  • new 等价于alloc+init

关于(uintptr_t)newCls >> 3，究竟为啥仍是有点含糊，仅仅猜测是节约内存，后边有新的发现再补充~