本文主要对以下几点进行介绍：

• 通过SIL来理解对象的创建
• Swift类结构分析
• 存储属性 & 计算属性
• 延迟存储属性 & 单例创建方式

SIL

在底层流程中，OC代码和Swift代码是通过不同的编译器进行编译，然后通过LLVM，生成.o可执行文件，流程如下图所示

Swift与OC编译流程图

• OC通过clang编译器，编译成IR，然后再生成可执行文件.o（这里也就是我们所说的机器码）
• Swift则是通过Swift编译器，编译成IR，然后再生成可执行文件.o

下面是Swift中的编译流程，其中SIL(Swift Intermediate Language)是Swift编译过程中的中间代码，主要用于进一步分析和优化Swift代码。如下图所示，SIL位于在AST和LLVM IR之间

Swift编译流程

注意：Swift与OC的区别在于Swift生成了高级的SIL

我们可以通过swiftc -h终端命令，查看swiftc的所有命令

swiftc命令

如果想要详细对SIL的内容进行探索，可以参考这个视频，也可以参考这个文档

例如：在main.swift文件定义如下代码

class SunriseTeacher {
    var age: Int = 18
    var name: String = "Sunrise"
}

let sunrise = SunriseTeacher()

• 查看抽象语法树：swiftc -dump-ast main.swift

抽象语法树

• 生成SIL文件：swiftc -emit-sil main.swift >> ./main.sil && code main.sil，其中main的入口函数如下：

// main
//`@main`：标识当前main.swift的`入口函数`，SIL中的标识符名称以`@`作为前缀
sil @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 {
//`%0、%1` 在SIL中叫做寄存器，可以理解为开发中的常量，一旦赋值就不可修改，如果还想继续使用，就需要不断的累加数字（注意：这里的寄存器，与`register read`中的寄存器是有所区别的，这里是指`虚拟寄存器`，而`register read`中是`真寄存器`）
bb0(%0 : $Int32, %1 : $UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>):
  //`alloc_global`：创建一个`全局变量`，即代码中的`sunrise`
  alloc_global @$s4main7sunriseAA14SunriseTeacherCvp // id: %2
  //`global_addr`：获取全局变量地址，并赋值给寄存器%3
  %3 = global_addr @$s4main7sunriseAA14SunriseTeacherCvp : $*SunriseTeacher // user: %7
  //`metatype`获取`SunriseTeacher`的`MetaData`赋值给%4
  %4 = metatype $@thick SunriseTeacher.Type       // user: %6
  //将`__allocating_init`的函数地址赋值给 %5
  // function_ref SunriseTeacher.__allocating_init()
  %5 = function_ref @$s4main14SunriseTeacherCACycfC : $@convention(method) (@thick SunriseTeacher.Type) -> @owned SunriseTeacher // user: %6
  //`apply`调用 `__allocating_init` 初始化一个变量，赋值给%6
  %6 = apply %5(%4) : $@convention(method) (@thick SunriseTeacher.Type) -> @owned SunriseTeacher // user: %7
  //将%6的值存储到%3，即全局变量的地址(这里与前面的%3形成一个闭环)
  store %6 to %3 : $*SunriseTeacher               // id: %7
  //构建`Int`，并`return
  %8 = integer_literal $Builtin.Int32, 0          // user: %9
  %9 = struct $Int32 (%8 : $Builtin.Int32)        // user: %10
  return %9 : $Int32                              // id: %10
} // end sil function 'main'

注意：code命令生效是在.zshrc文件中添加如下配置：

alias subl='/Applications/SublimeText.app/Contents/SharedSupport/bin/subl'
alias code='/Applications/Visual\ Studio\ Code.app/Contents/Resources/app/bin/code'

• SIL文件中，可以看出，代码是经过混淆的，可以通过以下命令还原，以s4main7sunriseAA14SunriseTeacherCvp为例：xcrun swift-demangle s4main7sunriseAA14SunriseTeacherCvp

混淆代码还原

• 在SIL文件中搜索s4main14SunriseTeacherCACycfC，其内部实现主要是分配内存+初始化变量
  • alloc_ref：创建一个SunriseTeacher的实例对象，当前实例对象的引用计数为1
  • 调用init方法

// s4main14SunriseTeacherCACycfC 实际就是__allocating_init()
// SunriseTeacher.__allocating_init()
sil hidden [exact_self_class] @$s4main14SunriseTeacherCACycfC : $@convention(method) (@thick SunriseTeacher.Type) -> @owned SunriseTeacher {
// %0 "$metatype"
bb0(%0 : $@thick SunriseTeacher.Type):
  // 堆上分配内存空间
  %1 = alloc_ref $SunriseTeacher                  // user: %3
  // function_ref SunriseTeacher.init() 初始化当前变量
  %2 = function_ref @$s4main14SunriseTeacherCACycfc : $@convention(method) (@owned SunriseTeacher) -> @owned SunriseTeacher // user: %3
  // 返回
  %3 = apply %2(%1) : $@convention(method) (@owned SunriseTeacher) -> @owned SunriseTeacher // user: %4
  return %3 : $SunriseTeacher                     // id: %4
} // end sil function '$s4main14SunriseTeacherCACycfC'

符号断点调试

• 在demo中添加__allocating_init符号断点

_ _allocating_init

• 发现其内部调用的是swift_allocObject

swift_allocObject

源码调试

下面我们就通过swift_allocObject来探索Swift中对象的创建过程

• 在REPL（命令交互行，类似于Python，可以在这里编写代码）中编写如下代码（也可以拷贝），并搜索swift_allocObject函数加一个断点，然后定义一个实例对象sunrise

创建实例对象

• 断点断住，查看左边Local有详细的信息

实例化断点断住

• 其中requiredSize是分配的实际内存大小，为40
• requiredAlignmentMask是Swift中的字节对齐，这个和OC中是一样的，必须是8的倍数，不足的会自动补齐，目的是以空间换时间，来提高内存操作效率

swift_allocObject 源码分析

swift_allocObject的源码如下，主要有以下几部分：

• 通过swift_slowAlloc分配内存，并进行内存字节对齐
• 通过new + HeapObject + metadata初始化一个实例对象
• 函数的返回值是HeapObject类型，所以当前对象的内存结构就是HeapObject的内存结构

static HeapObject *_swift_allocObject_(HeapMetadata const *metadata,
                                       size_t requiredSize,
                                       size_t requiredAlignmentMask) {
  assert(isAlignmentMask(requiredAlignmentMask));
  auto object = reinterpret_cast<HeapObject *>(
      swift_slowAlloc(requiredSize, requiredAlignmentMask));

  // NOTE: this relies on the C++17 guaranteed semantics of no null-pointer
  // check on the placement new allocator which we have observed on Windows,
  // Linux, and macOS.
  new (object) HeapObject(metadata); // 初始化一个实例对象

  // If leak tracking is enabled, start tracking this object.
  SWIFT_LEAKS_START_TRACKING_OBJECT(object);

  SWIFT_RT_TRACK_INVOCATION(object, swift_allocObject);

  return object;
}

• 进入swift_slowAlloc函数，其内部主要是通过malloc在堆中分配size大小的内存空间，并返回内存地址，主要是用于存储实例变量

void *swift::swift_slowAlloc(size_t size, size_t alignMask) {
  void *p;
  // This check also forces "default" alignment to use AlignedAlloc.
  if (alignMask <= MALLOC_ALIGN_MASK) {
#if defined(__APPLE__)
    p = malloc_zone_malloc(DEFAULT_ZONE(), size);
#else
    p = malloc(size); // 堆中创建size大小的内存空间，用于存储实例变量
#endif
  } else {
    size_t alignment = (alignMask == ~(size_t(0)))
                           ? _swift_MinAllocationAlignment
                           : alignMask + 1;
    p = AlignedAlloc(size, alignment);
  }
  if (!p) swift::crash("Could not allocate memory.");
  return p;
}

• 进入HeapObject初始化方法，需要两个参数：metadata、refCounts

HeapObject初始化方法

• 其中metadata类型是HeapMetadata，是一个指针类型，占8个字节
• refCounts（引用计数，类型是InlineRefCounts，而InlineRefCounts是一个类RefCounts的别名，占8个字节），Swift采用ARC 引用计数

RefCounts

总结

• 对于实例对象sunrise来说，其实质是一个HeapObject结构体，默认16字节内存大小（metadata8字节 + refCounts8字节），与OC的对比如下：
  • OC中的实例对象的本质是结构体，是以objc_object为模板继承的，其中有一个isa指针，占8个字节
  • Swift中的实例对象，比OC中的多了一个refCounts引用计数大小，默认属性占内存16个字节
• Swift中对象的内存分配流程是：__allocating_init --> swift_allocObject_ --> _swift_allocObject --> swift_slowAlloc --> malloc
• init在其中的职责就是初始化变量，这点与OC中是一致的

针对上面分析，我们还遗留了两个问题：metadata是什么，40是怎么计算的？下面来继续探索

在demo中，我们可以通过Runtime方法获取类的内存大小

类对象内存

这点与在源码调试时左边Local的requiredSize值是相等的，从HeapObject的分析中我们知道了，一个类在没有任何属性的情况下，默认占用16字节大小

对于Int、String类型，进入其底层定义，两个都是结构体类型，那么是否都是8字节呢？可以通过打印其内存大小来验证

//********* Int底层定义 *********
@frozen public struct Int : FixedWidthInteger, SignedInteger {...}

//********* String底层定义 *********
@frozen public struct String {...}

//********* 验证 *********
print(MemoryLayout<Int>.stride)
print(MemoryLayout<String>.stride)

//********* 打印结果 *********
8
16

从打印的结果中可以看出，Int类型占8字节，String类型占16字节（后面文章会进行详细讲解），这点与OC中是有所区别的

所以这也解释了为什么SunriseTeacher的内存大小等于40，即 40 = metadata（8字节） + refCount（8字节）+ Int（8字节）+ String（16字节）

这里验证了40的来源，但是metadata是什么还不知道，继续往下分析

HeapMetadata类型分析

下面就来分析metadata，看看它到底是什么？

• 进入HeapMetadata定义，是TargetHeapMetaData类型的别名，接收了一个参数Inprocess

using HeapMetadata = TargetHeapMetaData<Inprocess>;

• 进入TargetHeapMetaData定义，其本质是一个模板类型，其中定义了一些所需的数据结构。这个结构体中没有属性，只有初始化方法，传入了一个MetadataKind类型的参数（该结构体没有，那么只有在父类中了）这里的kind就是传入的Inprocess

//模板类型
template <typename Runtime>
struct TargetHeapMetadata : TargetMetadata<Runtime> {
  using HeaderType = TargetHeapMetadataHeader<Runtime>;

  TargetHeapMetadata() = default;
  //初始化方法
  constexpr TargetHeapMetadata(MetadataKind kind)
    : TargetMetadata<Runtime>(kind) {}
#if SWIFT_OBJC_INTEROP
  constexpr TargetHeapMetadata(TargetAnyClassMetadata<Runtime> *isa)
    : TargetMetadata<Runtime>(isa) {}
#endif
};

• 进入TargetMetaData定义，有一个kind属性，kind的类型就是之前传入的Inprocess。从这里可以得出，对于kind，其类型就是unsigned long，主要用于区分是哪种类型的元数据

//******** TargetMetaData 定义 ********
struct TargetMetaData{
  using StoredPointer = typename Runtime: StoredPointer;
   ...
   
   StoredPointer kind;
}

//******** Inprocess 定义 ********
struct Inprocess{
   ...
   using StoredPointer = uintptr_t;
   ...
}

//******** uintptr_t 定义 ********
typedef unsigned long uintptr_t;

从TargetHeapMetadata、TargetMetaData定义中，均可以看出初始化方法中参数kind的类型是MetadataKind

• 进入MetadataKind定义，里面有一个#include "MetadataKind.def"，点击进入，其中记录了所有类型的元数据，所以kind种类总结如下

name	value
Class	0x0
Struct	0x200
Enum	0x201
Optional	0x202
ForeignClass	0x203
Opaque	0x300
Tuple	0x301
Function	0x302
Existential	0x303
Metatype	0x304
ObjCClassWrapper	0x305
ExistentialMetatype	0x306
HeapLocalVariable	0x400
HeapGenericLocalVariable	0x500
ErrorObject	0x501
LastEnumerated	0x7FF

• 回到TargetMetaData结构体定义中，找方法getClassObject，在该方法中去匹配kind返回值是TargetClassMetadata类型
  • 如果是Class，则直接对this（当前指针，即metadata）强转为ClassMetadata

const TargetClassMetadata<Runtime> *getClassObject() const;
 
//******** 具体实现 ********
template<> inline const ClassMetadata *
  Metadata::getClassObject() const {
    //匹配kind
    switch (getKind()) {
      //如果kind是class
    case MetadataKind::Class: {
      // Native Swift class metadata is also the class object.
      //将当前指针强转为ClassMetadata类型
      return static_cast<const ClassMetadata *>(this);
    }
    case MetadataKind::ObjCClassWrapper: {
      // Objective-C class objects are referenced by their Swift metadata wrapper.
      auto wrapper = static_cast<const ObjCClassWrapperMetadata *>(this);
      return wrapper->Class;
    }
    // Other kinds of types don't have class objects.
    default:
      return nullptr;
    }
  }

这一点，我们可以通过lldb来验证

• po metadata->getKind()，得到其kind是Class
• po metadata->getClassObject()、x/8g 0x0000000110efdc70，这个地址中存储的是元数据信息

metadata数据信息

所以，TargetMetadata 和 TargetClassMetadata 本质上是一样的，因为在内存结构中，可以直接进行指针的转换，所以可以说，我们认为的结构体，其实就是TargetClassMetadata

• 进入TargetClassMetadata定义，继承自TargetAnyClassMetadata，有以下这些属性，这也是类结构的部分

template <typename Runtime>
struct TargetClassMetadata : public TargetAnyClassMetadata<Runtime> {
   ...
   // swift特有的标志
   ClassFlags Flags;
   // 实例对象内存大小
   uint32_t InstanceSize;
   // 实例对象内存对齐方式
   uint16_t InstanceAlignMask;
   // 运行时保留字段
   uint16_t Reserved;
   // 类的内存大小
   uint32_t ClassSize;
   // 类的内存首地址
   uint32_t ClassAddressPoint;
 ...
}

• 进入TargetAnyClassMetadata定义，继承自TargetHeapMetadata

template <typename Runtime>
struct TargetAnyClassMetadata : public TargetHeapMetadata<Runtime> {
    ...
    ConstTargetMetadataPointer<Runtime, swift::TargetClassMetadata> Superclass;
    TargetPointer<Runtime, void> CacheData[2];
    StoredSize Data;
    ...
}

总结

综上所述，当metadata的kind为Class时，有如下继承链：

类结构继承链

• 当前类返回的实际类型是 TargetClassMetadata，而TargetMetaData中只有一个属性kind，TargetAnyClassMetaData中有4个属性，分别是kind， superclass，cacheData、data（图中未标出）
• 当前Class在内存中所存放的属性由TargetClassMetadata属性 + TargetAnyClassMetaData属性 + TargetMetaData属性 构成，所以得出的metadata的数据结构体如下所示

struct swift_class_t: NSObject{
   void *kind;//相当于OC中的isa，kind的实际类型是unsigned long
   void *superClass;
   void *cacheData;
   void *data;
   uint32_t flags; //4字节
   uint32_t instanceAddressOffset;//4字节
   uint32_t instanceSize;//4字节
   uint16_t instanceAlignMask;//2字节
   uint16_t reserved;//2字节
   
   uint32_t classSize;//4字节
   uint32_t classAddressOffset;//4字节
   void *description;
   ...
}

与OC对比

• 实例对象 & 类
  • OC中的实例对象本质是结构体，是通过底层的objc_object模板创建，类是继承自objc_class
  • Swift中的实例对象本质也是结构体，类型是HeapObject，比OC多了一个refCounts
• 方法列表
  • OC中的方法存储在objc_class结构体class_rw_t的methodList中
  • Swift中的方法存储在 metadata 元数据中
• 引用计数
• OC中的ARC维护的是散列表
• Swift中的ARC是对象内部有一个refCounts属性

Swift属性

在swift中，属性主要分为以下几种

• 存储属性
• 计算属性
• 延迟存储属性
• 类型属性

存储属性

存储属性，又分两种：

• 要么是常量存储属性，即let修饰
• 要么是变量存储属性，即var修饰

定义如下代码

class SunriseTeacher {
    var age: Int = 18
    var name: String = "Sunrise"
}

let sunrise = SunriseTeacher()

其中代码中的age、name来说，都是变量存储属性，这一点可以在SIL中体现

class SunriseTeacher {
  @_hasStorage @_hasInitialValue var age: Int { get set }
  @_hasStorage @_hasInitialValue var name: String { get set }
  @objc deinit
  init()
}

存储属性特征：会占用分配实例对象的内存空间

下面我们同断点调试来验证

• po sunrise
• x/8g 内存地址，即HeapObject存储的地址

属性内存分布 HeapObject

计算属性

计算属性：是指不占用内存空间，本质是set/get方法的属性

我们通过一个demo来说明，以下写法正确吗？

class SunriseTeacher {
    var age: Int{
        get{
            return 18
        }
        set{
            age = newValue
        }
    }
}

在实际编程中，编译器会报以下警告，其意思是在age的set方法中又调用了age.set

计算属性-1

然后运行发现崩溃了，原因是age的set方法中调用age.set导致了循环引用，即递归

计算属性-2

验证：不占内存

对于其不占用内存空间这一特征，我们可以通过以下案例来验证，打印以下类的内存大小

class Square{
    var width: Double = 8.0
    var area: Double{
        get{
            //这里的return可以省略，编译器会自动推导
            return width * width
        }
        set{
            width = sqrt(newValue)
        }
    }
}

print(class_getInstanceSize(Square.self))

//********* 打印结果 *********
24

从结果可以看出类Square的内存大小是24，等于 （metadata + refCounts）类自带16字节 + width（8字节） = 24，是没有加上area的。从这里可以证明area属性没有占有内存空间。

验证：本质是set/get方法

• 将main.swift转换为SIL文件：swiftc -emit-sil main.swift >> ./main.sil
• 查看SIL文件，对于存储属性，有_hasStorage的标识符

class Square {
  @_hasStorage @_hasInitialValue var width: Double { get set }
  var area: Double { get set }
  @objc deinit
  init()
}

• 对于计算属性，SIL中只有setter、getter方法

计算属性-3

属性观察者（didSet、willSet）

• willSet：新值存储之前调用 newValue
• didSet：新值存储之后调用 oldValue

验证

• 可以通过demo来验证

class SunriseTeacher {
    var name: String = "旧值-wrs"{
        // 新值存储之前调用
        willSet{
            print("willSet newValue \(newValue)")
        }
        // 新值存储之后调用
        didSet{
            print("didSet oldValue \(oldValue)")
        }
    }
}

let sunrise = SunriseTeacher()
sunrise.name = "新值-sun"

//**********打印结果*********
willSet newValue 新值-sun
didSet oldValue 旧值-wrs

• 也可以通过编译来验证，将main.swift编译成mail.sil，在sil文件中找name的set方法

属性观察者-1

问题1：init方法中是否会触发属性观察者？

以下代码中，init方法中设置name，是否会触发属性观察者？

class SunriseTeacher {
    var name: String = "旧值-wrs"{
        // 新值存储之前调用
        willSet{
            print("willSet newValue \(newValue)")
        }
        // 新值存储之后调用
        didSet{
            print("didSet oldValue \(oldValue)")
        }
    }
    
    init() {
        self.name = "sunrise"
    }
}

运行结果发现，并没有走willSet、didSet中的打印方法，所以有以下结论：

• 在init方法中，如果调用属性，是不会触发属性观察者的
• init中主要是初始化当前变量，除了默认的前16个字节，其他属性会调用memset清理内存空间（因为有可能是脏数据，即被别人用过），然后才会赋值

总结：初始化器（即init方法设置）和定义时设置默认值（即在didSet中调用其他属性值）都不会触发

问题2：哪里可以添加属性观察者？

主要有以下三个地方可以添加：

• 1、类中定义的存储属性
• 2、通过类继承的存储属性

class SunriseMediumTeacher: SunriseTeacher{
    override var age: Int{
        // 新值存储之前调用
        willSet{
            print("willSet newValue \(newValue)")
        }
        // 新值存储之后调用
        didSet{
            print("didSet oldValue \(oldValue)")
        }
    }
}

• 3、通过类继承的计算属性

class SunriseTeacher {
    var age: Int = 18
    var age2: Int{
        get{
            18
        }
        set{
            self.age = newValue
        }
    }
}

let sunrise = SunriseTeacher()

class SunriseMediumTeacher: SunriseTeacher{
    override var age: Int{
        // 新值存储之前调用
        willSet{
            print("willSet newValue \(newValue)")
        }
        // 新值存储之后调用
        didSet{
            print("didSet oldValue \(oldValue)")
        }
    }
    
    override var age2: Int{
        // 新值存储之前调用
        willSet{
            print("willSet newValue \(newValue)")
        }
        // 新值存储之后调用
        didSet{
            print("didSet oldValue \(oldValue)")
        }
    }
}

问题3：子类和父类的计算属性同时存在didset、willset时，其调用顺序是什么？

有以下代码，其调用顺序是什么？

class SunriseTeacher {
    var age: Int = 18{
        // 新值存储之前调用
        willSet{
            print("父类 willSet newValue \(newValue)")
        }
        // 新值存储之后调用
        didSet{
            print("父类 didSet oldValue \(oldValue)")
        }
    }
    
    var age2: Int{
        get{
            18
        }
        set{
            self.age = newValue
        }
    }
     
}

class SunriseMediumTeacher: SunriseTeacher{
    override var age: Int{
        // 新值存储之前调用
        willSet{
            print("子类 willSet newValue \(newValue)")
        }
        // 新值存储之后调用
        didSet{
            print("子类 didSet oldValue \(oldValue)")
        }
    }
    
    override var age2: Int{
        // 新值存储之前调用
        willSet{
            print("子类 willSet newValue \(newValue)")
        }
        // 新值存储之后调用
        didSet{
            print("子类 didSet oldValue \(oldValue)")
        }
    }
}
 
let sunrise = SunriseMediumTeacher()
sunrise.age = 20

//**********打印结果*********
子类 willSet newValue 20
父类 willSet newValue 20
父类 didSet oldValue 18
子类 didSet oldValue 18

总结：对于同一个属性，子类和父类都有属性观察者，其顺序是：先子类willset，后父类willset，在父类didset， 子类的didset，即：子父 父子

问题4：子类调用了父类的init，是否会触发观察属性？

在问题3的基础，修改SunriseMediumTeacher类

class SunriseMediumTeacher: SunriseTeacher{
    override var age: Int{
        // 新值存储之前调用
        willSet{
            print("子类 willSet newValue \(newValue)")
        }
        // 新值存储之后调用
        didSet{
            print("子类 didSet oldValue \(oldValue)")
        }
    }
    
    override init() {
        
        super.init()
        self.age = 19
    }
}

//**********打印结果*********
子类 willSet newValue 19
父类 willSet newValue 19
父类 didSet oldValue 18
子类 didSet oldValue 18

从打印结果发现，会触发属性观察者，主要是因为子类调用了父类的init，已经初始化过了，而初始化流程保证了所有属性都有值（即super.init确保变量初始化完成了），所以可以观察属性了

延迟属性

延迟属性主要有以下几点说明：

• 1、使用lazy修饰的存储属性
• 2、延迟属性必须有一个默认的初始值
• 3、延迟存储在第一次访问的时候才被赋值
• 4、延迟存储属性并不能保证线程安全
• 5、延迟存储属性对实例对象大小的影响

1、使用lazy修饰的存储属性

class SunriseTeacher{
    lazy var age: Int = 18
}

2、延迟属性必须有一个默认的初始值

如果定义为可选类型，则会报错，如下所示

延迟属性-1

3、延迟存储在第一次访问的时候才被赋值

可以通过调试，来查看实例变量的内存变化

• age第一次访问前的内存情况：此时的age是没值的，为0x0

延迟属性-2

• age第一次访问后的内存情况：此时age是有值的，为20

延迟属性-3

从而可以验证，懒加载存储属性只有在第一次访问时才会被赋值

我们也可以通过sil文件来查看，这里可以在生成sil文件时，加上还原swift中混淆名称的命令(即xcrun swift-demangle)：swiftc -emit-sil main.swift | xcrun swift-demangle >> ./main.sil && code main.sil，demo代码如下

class SunriseTeacher{
    lazy var age: Int = 18
}

var sunrise = SunriseTeacher()

sunrise.age = 20

• 类+main：lazy修饰的存储属性在底层是一个optional类型

延迟属性-4

• setter+getter：从getter方法中可以验证，在第一次访问时，就从没值变成了有值的操作

延迟属性-5

通过sil，有以下两点说明：

• 1、lazy修饰的属性，在底层默认是optional，在没有被访问时，默认是nil，在内存中的表现就是0x0。在第一次访问过程中，调用的是属性的getter方法，其内部实现是通过当前enum的分支，来进行一个赋值操作

• 2、可选类型是16字节吗？可以通过MemoryLayout打印

  • size：实际大小
  • stride：分配大小（主要是由于内存对齐）

print(MemoryLayout<Optional<Int>>.stride)
print(MemoryLayout<Optional<Int>>.size)

//*********** 打印结果 ***********
16
9

为什么实际大小是9？Optional其本质是一个enum，其中Int占8字节，另一个字节主要用于存储case值（这个后续会详细讲解）

4、延迟存储属性并不能保证线程安全

继续分析3中sil文件，主要是查看age的getter方法，如果此时有两个线程：

• 线程1此时访问age，其age是没有值的，进入bb2流程
• 然后时间片将CPU分配给了线程2，对于optional来说，依然是none，同样可以走到bb2流程
• 所以，在此时，线程1会走一遍赋值，线程2也会走一遍赋值，并不能保证属性只初始化了一次

5、延迟存储属性对实例对象大小的影响

下面来继续看下不使用lazy的内存与使用lazy的内存是否有变化？

• 不使用lazy修饰的情况，类的内存大小是24

延迟属性-6

• 使用lazy修饰的情况下，类的内存大小是32

延迟属性-7

从而可以证明，使用lazy和不使用lazy，其实例对象的内存大小是不一样的

类型属性

类型属性，主要有以下几点说明：

• 1、使用关键字static修饰，且是一个全局变量
• 2、类型属性必须有一个默认的初始值
• 3、类型属性只会被初始化一次

1、使用关键字static修饰

class SunriseTeacher{
    static var age: Int = 18
}

// **** 使用 ****
var age = SunriseTeacher.age

生成SIL文件

• 查看定义，发现多了一个全局变量，说以，类型属性是一个全局变量

类型属性-1

• 查看入口函数中age的获取

类型属性-2

• 查看age的getter方法

类型属性-3

• 其中 globalinit_029_12232F587A4C5CD8B1EEDF696793B2FC_func0是全局变量初始化函数

类型属性-4

• builtin "once" ，通过断点调试，发现调用的是swift_once，表示属性只初始化一次

类型属性-5

• 源码中搜索swift_once，其内部是通过GCD的dispatch_once_f单例实现。从这里可以验证上面的第3点

void swift::swift_once(swift_once_t *predicate, void (*fn)(void *),
                       void *context) {
#if defined(__APPLE__)
  dispatch_once_f(predicate, context, fn);
#elif defined(__CYGWIN__)
  _swift_once_f(predicate, context, fn);
#else
  std::call_once(*predicate, [fn, context]() { fn(context); });
#endif
}

2、类型属性必须有一个默认的初始值

如下图所示，如果没有给默认的初始值，会报错

类型属性-6

所以对于类型属性来说，一是全局变量，只初始化一次，二是线程安全的

单例的创建

//****** Swift单例 ******
class SunriseTeacher{
    //1、使用 static + let 创建声明一个实例对象
    static let shareInstance = SunriseTeacher.init()
    //2、给当前init添加private访问权限
    private init(){ }
}
//使用(只能通过单例，不能通过init)
var t = SunriseTeacher.shareInstance

//****** OC单例 ******
@implementation SunriseTeacher
+ (instancetype)shareInstance{
    static SunriseTeacher *shareInstance = nil;
    dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        shareInstance = [[SunriseTeacher alloc] init];
    });
    return shareInstance;
}
@end

总结

• 存储属性会占用实例变量的内存空间
• 计算属性不会占用内存空间，其本质是set/get方法
• 属性观察者
  • willset：新值存储之前调用，先通知子类，再通知父类（因为父类中可能需要做一些额外的操作），即子父
  • didSet：新值存储完成后，先告诉父类，再通知子类（父类的操作优先于子类），即父子
  • 类中的init方法赋值不会触发属性观察
  • 属性可以添加在类定义的存储属性、继承的存储属性、继承的计算属性中
  • 子类调用父类的init方法，会触发观察属性
• 延迟存储属性
  • 使用lazy修饰存储属性，且必须有一个默认值
  • 只有在第一次被访问时才会被赋值，且是线程不安全的
  • 使用lazy和不使用lazy，会对实例对象的内存大小有影响，主要是因为lazy在底层是optional类型，optional的本质是enum，除了存储属性本身的内存大小，还需要一个字节用于存储case
• 类型属性
  • 使用static修饰，且必须有一个默认初始值
  • 是一个全局变量，只会被初始化一次，是线程安全的
  • 用于创建单例对象：
    • 使用static + let创建实例变量
    • init方法的访问权限为private