目录

• 代码诊断
  • 地址诊断
  • 线程诊断
  • 未定义行为诊断
  • 主线程检查
• 内存管理
  • malloc 填充
  • malloc 保护页
  • malloc 保护
  • 僵尸对象
• 日志
  • malloc 调用栈
  • 动态链接器 API 调用
  • 动态链接器库加载

Xcode 中 scheme 设置里面有一栏 Diagnostics 选项, 方便进行调试, 可以分为代码诊断, 内存管理, 和日志三部分, 从这三个角度分析程序潜在的问题.

代码诊断

代码诊断分为地址诊断, 线程诊断和未定义行为诊断, 可以在[苹果官网][xocde]上查看详细说明.

地址诊断

用于检查内存使用问题, 可以检查以下类型的代码错误:

• 使用被释放的内存

• 重复释放内存

• 释放未申请过的内存

• 将栈内存做为函数返回值

• 使用离开了作用域的栈内存

• 内存越界

其实现原理为重写了 malloc 和 free 的实现, 内存在使用 malloc 申请之前被标记为禁止使用的, malloc 申请内存后, 申请部分的内存标记为可以使用; free 后内存被重新标记为禁止使用. 进行内存访问时, 会先检查内存是否可以使用.

线程诊断

会检查线程上不安全的行为:

• 数据争用

• 使用未初始化的锁

• 线程泄漏

开启线程诊断后, 每次内存调用都会进行线程安全检查. 安全检查会对上述不安全行为进行检查, 比如每个线程都会保存内存访问时的时间戳, 如果对于同一块内存, 多个线程对其访问的时间戳有重叠且其中有写操作, 就判定为数据争用; 使用锁时会先判断其是否已经初始化; 还会检查不使用的线程是否被正确释放掉.

未定义行为诊断

对未定义(不好分类)的行为进行检查, 这些行为的名称不太直观, 所以展开来说明. 不过基本上很少会出现这些问题吧…

• 内存对齐

直接对内存地址进行赋值可能会造成内存不对齐的情况

int_8 *buffer = malloc(64);
int_32 *pointer = (int_32 *)(buffer + 1);
*pointer = 123;

如果内存是32位对齐, 那么 pointer 是从第8位之后写入一个32位数据, 显然内存没有对齐. 推荐的方法是使用 memset 函数, 在编译过程中发现未对齐内存时会生成优化的汇编指令.

• 无效的 boolean 值

使用 int 作为 boolean 进行判断时, 非零的值代表 true, 但编译器可能会对 boolean 进行优化, 只判断它的最后一位是否为0, 造成了逻辑错误.

• 数组越界

语义上的数组越界检查, 和上面的广义的, 本质上的内存越界检查是有区别的.

• 无效的枚举值

使用 int 来表示 enum 使, int 可能会取到 enum 没有定义的值.

• 跳转到控制流之外

比如 switch 语句中的所有 case 都没有命中

• 动态类型错误

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
struct Animal {
    virtual const char *speak() = 0;
};
​
struct Cat: public Animal {
    const char *speak() {
        return "nya";
    }
};
​
struct Dog: public Animal {
    const char *speak() {
        return "woof";
    }
};
​
auto *dog = reinterpret_cast<Dog *>(new Cat);
dog->speak();

reinterpret_cast 进行了无关类型之间的类型转换, 上面这种不正当地使用多态可能会引起难以预测的行为.

• 浮点数溢出

• 0作除数

• nonnull 相关的检查

• 空指针引用和调用

• 不正确的对象大小

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
struct Base {
    int pad;
};
​
struct Derived: Base {
    int pad2;
};
​
Derived *getDerived() {
    return static_cast<Derived *>(new Base);
}

还是多态使用的问题, getDerived 返回的指针指向的内存比 Derived 类型所占的内存要小, 当调用 getDerived()->pad2 时会发生错误.

• 左移溢出

• 整型溢出

上述问题并不都会发生错误, 开启了未定义行为诊断后使得代码检查变得更为严格.

地址诊断, 线程诊断, 未定义行为诊断都会在编译阶段增加了额外的代码和检查, 所以勾选后要重新编译.

主线程检查

会检查 AppKit, UIKit 和其他与 UI 有关的操作是否都在主线程进行, 检查是在 runtime 中进行的, 不需要重新编译, 而且性能损耗较少, 默认是开启的.

内存管理

malloc 填充

已申请的内存填充为 0xAA, 未申请和释放掉的内存填充为 0x55

malloc 保护页

在申请的大块内存前后会加上保护页, 防止内存越界

malloc 保护

进行越界的内存读写时, 会直接触发 crash

僵尸对象

开启后释放掉的内存只会被标记为僵尸对象, 不会被系统回收, 程序调用被释放的内存时会发生 crash, 打印错误日志.

开启了 malloc 保护页和僵尸对象后, 内存占用会上升, 与实际程序占用内存不符, 所以这勾选这两个选项后, 调试界面的内存占用将不会显示内存占用情况.

日志

malloc 调用栈

会记录每一次 malloc 时的函数调用, Debug Memory Tool 使用.

启用后, 调试时点击 Debug Memory Tool 后, 右侧可以查看内存 malloc 时的调用栈信息. 除此之外, 使用模拟器调试时, 可以使用命令行工具(不是 lldb 中)malloc_history 查看对应 pid(可以在 xcode log 中找到), 来查看 malloc 调用栈日志.

动态链接器 API 调用

开启后可以在 xocde 中输出动态链接器 API 的调用日志

动态链接器库加载

开启后可以在 xocde 中输出 dyld 加载动态链接库的日志

自己真正走完流程的也就这一家, 感觉秋招还是挺顺利的, 虽然 BAT 之类的面试机会都没有, 但最先面试的美团直接通过了, 也没什么可遗憾的. 比起面经更像是自己记录一下过程, 乱七八糟的可能会有点多, 有些自己当时不熟悉并且重要的知识点之后再详细补上吧, 再不写点多西自己都闲得长毛了.

目录

• 预习
• 一面(电话面试)
  • 自我介绍
  • 程序运行时内存的分布
  • 进程和线程的区别
  • 一个程序从编译到运行的全过程
  • 网络分层
  • HTTPS 的原理
  • 面向对象的特点
  • swift 中的值类型和引用类型
  • 求数组中前 k 大的数字
  • 额, 智力题
  • 学习 iOS 的途径
• 二面
  • 链表排序
  • 还是一道小智力题orz
  • 在 swift 协议中做用泛型
  • 编译, 链接过程
  • 学习途径
  • 最近学习过程中有什么知识点值得一提的
• 三面
  • 各种排序
  • 各种 swift
  • 项目
  • 有没有看今年的 WWDC
  • 最近在看什么书, 有什么可以值得分享的
  • 介绍岗位

预习

学校讲的课emmm基本没用, 还是得自己另学. 书籍的话, 准备面试的时候网络看了《计算机网络自顶向下方法》, 计原, 或者说编译原理方向看了《程序员的自我修养链接装载与库》算法因为时间不够, 刷了两遍多《剑指offer》, 因为现在还是 OC 主流, 补了下 OC 基础, 看了《Objective-C编程全解》《Objective-C高级编程: iOS 与 OS X 多线程和内存管理》. 其他的书都是之前积累的了, 太多了不列举了.

一面(电话面试)

8月31号投的简历, 没想到进了提前批, 没过几天就电话面试了, 免了笔试, 因为当时还没怎么准备好(当然多长时间也准备不好的), 也没抱什么希望.

自我介绍

从来没有面过技术面, 就介绍了一下自己的专业(因为是五年制, 说明了一下), 兴趣爱好, 和简历上的项目.

被问到了学校都有哪些课程, 和电有关的专业都会学到的数学, 电路理论, 模电, 数电; 计算机基础的离散数学, C语言, C++; 比较重要的编译原理, 网络, 组成原理, 操作系统; 工程方向的专业选修, 以及数据库, 软件工程之类的. 哦对, 还有日语课, 专业本身是挺好的, 就是课程安排不合理, 我在准备秋招的时候, 从日本交流回来的同学才开始学 C++, 也是有意思.

程序运行时内存的分布

• BSS段用于存放未初始化的全局变量, 程序开始运行之后会被清空, 静态分配

• 数据段用于存放初始化后的全局变量, 静态分配

• 代码段用于存放代码

• 栈区用于存放自动变量, 以及函数调用, 由系统管理内存分配

• 堆区用于存放动态分配的内存, 要由程序员手动进行管理

又简单说了一下栈区和堆区的区别, 不多写

进程和线程的区别

进程是操作系统资源分配的最小单位, 线程是处理机分配的最小单位, 一个程序至少有一个进程, 一个进程至少有一个线程. 进程间内存虚拟地址是独立的, 而线程间内存是共享的.

被问到线程间共享的内存是上面内存分布是提到的哪些区域, 因为线程之间是可以并行的, 所以和函数调用相关的栈内存不可以区享, 而是每个线程都佳能自己独立的栈区, 堆区内存是可以共享的. 至于共享内存会出现的同步问题, 可以用线程锁或者信号量解决, 又简单说了下锁和信号量.

一个程序从编译到运行的全过程

• 宏定义展开

• 词法分析

• 语法分析

• 语义分析

• 中间代码生成

• 中间代码优化

• 生成机器码

• 链接

• 装载到内存运行

其中链接详细问了一下, 就把静态链接和动态链接的区别, 优缺点解释了一下.

网络分层

OSI 的七层当时硬是没想出来, 就按 TCP/IP 四层结构详细地讲了一遍, 因为啃过自顶向下方法那本计算机网络书, 所以自我感觉说得可以, 面试官也没多问.

HTTPS 的原理

因为我说过自己有信息安全的课程, 就问我课上都讲了什么, 其实课上也就是科普了一下加密及运用, 以及防火墙之类的东西, 自然而然地就问了下我 HTTPS 是怎么实现安全的传输的. 提了下使用非对称加密通过证书机构来验证服务器身份, 并交换对称加密的密钥, 验证身份后使用对称加密来传输数据以减少资源和时间浪费, 本来想详细说明一下过程的, 没让我讲完…

面向对象的特点

封装, 继承和多态, 然后举了例子说明了一个程序如果用面向过程的思想应该怎么写, 用面向对象的思想应该怎么写

swift 中的值类型和引用类型

讲面向对象的时候我用了 C++ 和 swift 进行了比较, 所以就问了下 swift 的问题. 值类型的变量可以保证变量本身不会被其他变量所修改, 而引用变量则可能会被其他引用(指针)对变量指向的内存进行修改. 值类型因为赋值或修改会进行复制, 会浪费性能, swift 中使用写时复制的机制来提高其性能.

举了很多值类型的例子, 所以问我如果只有值类型可不可以, 使用指针那样的机制也可以达到同样的效果. 懵了一下, 回答说那样就不能进行多态了, 然后马上意识到自己说得不对…使用指针操作值类型本身就是按照引用类型的语义来操作值类型, 还不如直接使用引用类型更容易理解一些. 和何况有些情况使用引用类型本身各贴近正常的思维, 比如一个人的多个身份相当于这个人的多个引用, 指向这个人本身.

求数组中前 k 大的数字

《剑指 offer》上的原题, 就回忆了一下:

• 数组大小 n 比较小

直接排序取前 k 个就好了, 本身也花不了多长时间, 使用快排的话时间复杂度就是 O(nlogn).

• n 很大

用于一个 k 个元素的小顶堆, 将数组中的元素入堆, 堆满之后, 下一个元素比堆顶大就弹出堆顶, 新元素入堆, 否则跳过. 相当于堆里始终存放着当前最大的 k 个元素. 小顶堆建立的过程中时间复杂度为 O(klogk), 之后每次堆的复杂度为 O(logk), 即若 k 远远小于 n 的话, 时间复杂度为 O(nlogk).

因为题目很简单, 所以问得特别细, 问了快排和堆排为什么时间复杂度是 O(nlogn). 快排每一轮都是O(n), 每轮相当于将数组分成一半, 所以排了 logn 轮(以2为底); 堆排每次调整最多要调整的次数就是堆的深度, 即 logn (以2为底).

额, 智力题

一个函数foo()会返回0或1, 概率分别是 70% 和 30%, 设计一个函数bar(), 使其返回0和1和概率各为 50%.

之前没做过这种题, 一脸懵逼, 然后想到调用两次foo()都返回0的概率是 70% * 70% = 49% , 和 50% 差不多了, 面试官应该没见过这样的操作, 也懵了hhh, 说这个方法不太好, 要是换成0和1的概率是 80% 和 20% 就行不通了, 让我再想.

后来提示我运行两次结果为01和10的概率是相同的. 当时我给出答案:

运行两次foo(), 当结果为01时, 返回0, 结果为10时, 返回1, 其余情况不返回, 重新运行, 直接有返回为止.

现在想00, 11的概率也是相同的, 可以把00, 01分为一组, 11, 10分为一组, 就不用轮空了.

接着又问我如果还是用这个函数foo(), 设计一个随机数函数返回0到9之间的随机数应该怎么做. 根据上面的做法, 用二进制表示返回值, 9是4位二进制数, 那么运行bar()函数4次, 如果结果大于9就轮空, 否则返回.

学习 iOS 的途径

感觉学校里做 iOS 的也就我一个人了, 就谈了谈自己看过的官方文档, 书籍, 视频和博客, 以及查资料的方法. 之后闲聊几句就结束了.

二面

感觉一面很基础, 也挺简单, 但是后面智力题尬了好久, 有些担心会被刷, 结果第二天就通知我去北京总部面试. 反正不会有大公司来大连面试的, 没多想就买了小火车票, 面不上就当是见见世面了.

链表排序

一开始问我电话面试感觉怎么样, 傻傻地说了算法可能没回答好, 然后面试官就说那好我们先写个算法吧orz, 就让我写个给链表排序的算法. 算法写得少, 从来没给链表排过序…想了好久, 写了个抠脚的O(n^2)的插入排序, 还好没写错, 想着上来就写成这样应该是凉了.

接着问我复杂度是多少, 有没有更快的方法, 我就给理了一下归并排序的实现, 发现取链表中点不好取, 就使用一个指针沿链表走一步, 另一个走两步的方法. 之后立即发现了, 找中间的复杂度就已经是O(n)了, 再加上归并本身的O(nlogn), 更慢了……

又问我快排行不行, 想了一下, 快排的实现并没有信赖数组的线性储存特点, 可以进行O(nlogn)的排序, 写出来也很简单:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
ListNode* partition(ListNode* start, ListNode* end) {
    int key = start->value;
    ListNode* p = start;
    ListNode* q = p->next;
    while (q != end) {
        if (q->value < key) {
            p = p->next;
            swap(p->value, q->value);
        }
        q = q->next;
    }
    swap(p->value, start->value);
    return p;
}

void qsort(ListNode* start, ListNode* end) {
    if (start == nullptr || end == nullptr) {
        return;
    }
    if (start != end) {
        ListNode* mid = partition(start, end);
        qsort(start, mid);
        qsort(mid->next; end);
    }
}

还是一道小智力题orz

真是怕什么来什么, 又问一道智力题, 6个候选人, 5个裁判, 设计一个公平的算法, 给候选人进行排序, 不允许并列.

出完题面试官就用我手机进我博客里看了(就是你现在看的这个), 我一直在想具体的实现应该怎么做, 结果面试官看完了, 我还是没有具体的方案. 面试结束后问了下这题应该怎么做, 得到的答案也很笼统, 大意就是设置好梯度…

在 swift 协议中做用泛型

其实就是associatedtype, swift 的协议中没有泛型, 因为协议是用来实现多继承, 或者模范一个类的实现, 我们可以让一个类实现一个协议, 但不会创建多个协议本身. 所以比起协议泛型, associatedtype这种类型别名的方式更适合.

可惜的是, 平时泛型用得少, 当时我忘了这个关键字就什么了, 只记得实现类的时候要对associatedtype的别名进行typealias绑定到已有的类型上…

编译, 链接过程

和一面问得差不多, 但在动态链接上问得更加详细, 编译出的二进制文件中指令操作的地址是写死的, 但动态链接库在加载时人位置不确定, 如何保证程序正常运行. 因为编译的时候不知道动态链接库的位置, 所以编译后二进制文件中动态库的地址只是占位用, 在程序装载到内存准备运行时, 会把动态库的位置替换掉原来的占位符. 当时意思是答出来了, 不知道对方有没有理解.

学习途径

说我课程时并没有 iOS 相关的东西, 为什么学起了 iOS. 就把一面时那些东西又说了一遍

最近学习过程中有什么知识点值得一提的

想着这是最后发挥的机会了, 就把准备面试过程中 OC 和 swift 的 block 原理从头到尾讲了一遍(之前文章里有写), 感觉面试官很满意.

二面一开始, 手表就提示我心率过速, 中间又提示了好几次. 面完还问了下面试官是不是自己要凉, 对方告诉我没事, 可能自己身边没人交流, 有些知识点发散得不够, 其实学过的东西还是挺扎实的.

三面

本来都以为 HR 会让自己回去了, 结果三面的面试官过来了, 顿时觉得自己还有救. 面试官刚过来就让我看一下他的牌, 说自己是美团移动端的技术总监, 当时太紧张, 上面写的什么一个字也没看进去. 一开始和我谈学校还有家里住哪之类的还以为对方是 HR, 第二天 HR 电话通知我结果的时候才知道是安卓和 iOS 双修, 两头都管的真dalao…

各种排序

还是问了下上一面都问了什么, 这回我学聪明了点, 没提智力题的事, 就说链表排序之前没写好, 费了点时间, 果然让我讲一下常用的排序. 这个肯定要好好复习的, 详细地说了一遍. 之后问了有没有O(n)的排序方法, 就提了下使用 hash, 以及基数排序.

各种 swift

我还纳闷怎么不问 iOS 相关的东西, 结果都攒到三面问了…因为我说过一直用的是 swift, 就问我 swift 与 OC 相比好在哪里, 把自己想到的都说了, 说了好久.

• 值类型&引用类型

除了一面时说的那些, 举例说明了一下值类型(struct 和 enum)和引用类型(class)的使用, 说mutation函数的时候被吐槽日语学多了英语不会读.

• 泛型

没怎么用过, 所以没说太多, 简单地和 OC 这种基本没泛型的语言比较了一下.

• 异常处理

try, catch这种语言上定义的异常处理自然要比NSError这种没有语言约束的错误处理要强, 可以强制程序员在处理会抛出异常的函数时会对错误情况进行思考写出catch条件, 而不是简单地传进一个nil指针. 同时 swift 的类型匹配以及强大的枚举类型使得可以更方便得通过抛出的Error得出异常信息, try, catch性能上的损失也远比 C++ 这要少.

• 枚举

就 siwft 中的强类型的枚举和C语言中可以用int替换的枚举进行对比, 又讨论了枚举的关联值和原始值, 还结合了一下上面提到的异常处理.

• 可选值

提到枚举又想到了可选值, 批判了NULL的问题, 讲了下可选值的解包, 可选链. 和面试官讨论了强制解包的坏处, 以及自己实践过的数组越界是不让其崩溃, 而是返回nil时带来的问题.

项目

项目没问太细, 只是了解了一下是做什么的, 用了什么技术, 用这些技术的原因.

有没有看今年的 WWDC

三面还是谈人生谈理想的东西多一些, 让我说一下对 iOS 发展的看法, 以及今年 WWDC 上有什么技术想和他说一说. 因为一直以来使用的都是越狱的 iOS, 就对苹果封闭生态的优缺点谈了谈, 认为就像逐步开放输入法, 通知中心, 分享菜单, Siri Kit 等, 越来越开放才是趋势. WWDC 这头谈了自己对ARKit以及Create ML的看法, 好在自己还真看了 WWDC, 虽然自己从来没用过, 吹吹牛逼还是可以的.

最近在看什么书, 有什么可以值得分享的

说了几本准备面试时看的 iOS 底层的书, 然后提了下之前研究过的 OpenWRT 路由和 IPv6 NAT(之前文章有写). 面试官之前做过网络, 就问了下 NAT 的实现, 怎么解决 IP 不足的. 详细地解释了一下.

介绍岗位

之后就没什么正经问题了, 给我介绍了下部门规模, 做什么业务, 最后问了下我对美团 app 的看法, 和对面试的评价, 就结束了.

本来二面觉得自己凉了, 三面之后完全没有这种感觉, 没让我想到的是面完后三面面试官开车送我到地铁站, 把我吓坏了…

目录

• 题目
• 读题
• 求解
• C++ 代码

题目

有一种将字母编码成数字的方式: ‘a’ -> 1, ‘b’ -> 2, … , ‘z’ -> 26.

现在给一串数字，给出有多少种可能的译码结果。

读题

一位数的时候, 只有一种解码; 两位数时, 如果数字在 1 到 26 之间, 就可以有两种解码. 要特别注意一下 0, 它本身是没有解码的, 只有 10 和 20 可以解码, 也就是说 100, 30 这种输入是没有解码结果的.

求解

首先是输入是否合法, 对于无输入或者 0, 直接返回 0.

之后从前向后扫描, 对于非 0 元素, 会有两种情况: 它与前面的数字在 1 到 26 之间, 或者不在. 如果不在, 那么它对于解码方法的增加没有贡献, 也是就和它前面的字符串的解码方式相等; 如果在 1 到 26 之间, 就会有把它当成1位数解码和当成2位数解码两种方式, 那么整个字符串的解码方式加 1.

如果扫描到 0, 那么不但它对解码方式增加没有贡献, 还会限制它前面的一个字符: 组合成 10 或 20 时, 0 前面的字符就不能和更前面的字符组合成两位数, 这时解码方式等于前n-2个字符的解码方式; 而如果不能组合成 10 或者 20, 就没办法进行解码, 解码方式为 0.

C++ 代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
int solution(string str) {
    // 排除空输入或者 0 开头的数字
    if (str.size() == 0 || str.front() != '0') {
        return 0;
    }
    // dp[i] 表示到第 i 个字符为止所有解码方式
    vector<int> dp(str.size(), 0);
    // 上面判断了第一个字符不是 0, 所以有一种解码
    dp[0] = 1;
    // 从前向后遍历
    for (int i = 1; i < str.size(); ++i) {
        // 如果当前位不是 0, 那么至少和之前的解码数目相同
        if (str[i] != '0') {
            dp[i] = dp[i - 1];
        }
        // 如果可以和前面组合成可解码数字, 解码方式增加
        if (dp[i - 1] == '1' || (dp[i - 1] == '2' && dp[i] < '6')) {
            if (i - 2 < 0) {
                // 正好是最前面的两个数字, 直接加 1
                ++dp[i];
            } else {
                // 否则再加上前 i - 2 位解码方式
                dp[i] += dp[i - 2];
            }
        }
    }
    // dp 中最后一个元素就是到到最后一个字符为止的解码方式
    return dp.back();
}

看到 dp 数组只用到了两个元素, 空间占用上可以再优化, 不过那样就更看不懂了, 不写了.

目录

• 直接看汇编
  • 位运算
  • 除法
• 移位操作

直接看汇编

对照C语言代码:

 1
 2
 3
 4
 5
 6
 7
// 除法
int a = 8;
int b = a / 2;

// 位运算
int a = 8;
int b = a >> 2;

一定要用中间变量储存结果, 否则编译器会优化(开了-O0也没用), 不会生成对应的汇编代码. 使用clang -O0 -S c_file -o nasm_file将C语言代码转换成汇编.

位运算

 1
 2
 3
 4
movl    $8, -4(%rbp)
movl    -4(%rbp), %ecx
sarl    $1, %ecx
movl    %ecx, -8(%rbp)

去掉无关的代码, 位运算代码转换成汇编就这几步:

• 将8入栈(因为是自动变量, 所谓的存入栈区)
• 将栈中变量取出, 放入通用寄存器ecx
• 将ecx寄存器中数据右移一位, 结果存在ecx中
• 将ecx数据入栈

除法

 1
 2
 3
 4
 5
 6
 7
 8
 9
movl    $2, %ecx
movl    $8, -4(%rbp)
movl    -4(%rbp), %edx
movl    %eax, -12(%rbp)
movl    %edx, %eax
cltd
idivl   %ecx
movl    %eax, -8(%rbp)
movl    -12(%rbp), %eax

因为没系统学过汇编, 所以看除法比上面位运算要麻烦得多.

• 向通用寄存器ecx中存入2(因为不是自动变量, 不入栈)
• 将8入栈
• 将栈变量取出, 放入通用寄存器edx
• 将累加寄存器eax中数据暂存入栈中(一会解释)
• 把edx数据移入eax
• 将eax扩充为四字(8字节)
• 将ecx数据作为除数计算除法
• 将eax中的结果入栈(赋给变量a)
• 将上面栈中暂存的eax数据放回eax

就看这多出来的步骤就比位移要麻烦. 首先解释一下除法, 计算机底层做除法时, 被除数位数是除数两倍长, 所以可以看到要使用edx的空间, 把eax扩充为四字, 然后用idivl命令的操作数ecx作为除数进行计算, 计算结果存放在eax中, 余数存在edx中, 但并没有看到对edx数据做什么处理, 也符合整型除法不管余数的原则.

再说明一下把eax数据入栈的操作, 因为累加寄存器中的数据还有用处, 但下一步除法要用它存放被除数, 此时四个寄存器eax, ebx, ecx, edx都用上了, 所以暂时从栈里借点地方, 之后再还回来.

移位操作

如果还是进行除法操作, 换成用无符号整型, 会发现生成的汇编和位运算一样:

 1
 2
unsigned int a = 8;
unsigned int b = a / 2;

这就要提一下有符号和无符号的移位操作了. 无符号的整型无所谓, 正常左移右移就可以, 而有符号整型有符号位, 在 macOS 上的 LLVN 9.1.0 中, 正数右移左面补0, 负数右移左面补1, 相当于符号位不变; 而左移会给出警告, 提示结果未定义, 忽略警告执行的话, 符号位不变, 正数右面补0, 负数补1. 总体来说, 和直觉相对.

虽然结果上是对的, 但有符号整型的左移毕竟是未定义行为, 所以在除法时会做出判断, 体现在汇编上就是使和idivl指令, 而不是右移sarl. 再加上除法会计算余数, 即使用不上, 所以在步数上和指令本身执行时间都不如移位.

看上去很简单的道理, 其实后面包含自底向上的组成原理, 编译原理, 汇编和C语言知识. 汇编真有趣, 我再也不看了…

目录

• block 的基本形式
• block 的值捕获
• block 也是对象
• block 储存方式
• ARC 下的 block
• block 的实现
  • block 本质是对象
  • block 捕获的变量
  • block 的复制
  • block 中对象的所有权

block 其实并不是 Objective-C 的语法, 而是苹果对于C语言的扩充, 所以完全可以在C文件中写 block, 然后使用 clang 来编译:

 1
$ clang block.c -o block

编译通过, 而且正常运行. 虽然 swift 不像 objc 是翻译成 C 再编译的, 但关于 block 与闭包的思想是相近的.

block 的基本形式

只考虑函数特性的话, block 与函数指针的形式基本一致

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 函数指针
// 声明
void (*foo)(void);
// 使用
foo();
(*foo)();
// 数组
void (*foo[5])(void);
// 作为函数参数, bar 为函数名, param 为作为参数的函数指针
void bar(void (*param)(void)) { }
// 作为函数返回值, foo 为函数名
void (*foo(void))(void) { }

// block
// 声明
void (^block)(void);
// 使用
block();
// 数组
void (^block[5])(void);
// 作为函数参数
void bar(void (^param)(void)) { }
// 作为函数返回值
void (^foo(void))(void) { }

因为 block 并不是指针, 所以调用 block 时不可以像函数指针一样使用*, 其他形式与函数指针都是一致的. 当然, 为了便于读写, 一般会使用typedef简化, 上面把 block 作为返回值的函数如果这样写会看起来会方便很多

 1
 2
typedef void (^block)(void);
block foo(void) { }

定义 block 时, 返回值可以跟据 block 内容推断出来, 所以可以省略, 而参数列表为空时, 也可能省略

 1
 2
 3
 4
 5
 6
 7
void (^block)(void) = ^void (void) {
    // something
}

void (^block)(void) = ^ {
    // something
}

上面两个 block 的定义是等价的.

block 的值捕获

和函数指针不同的是, block 可以捕获外部的值, 在C语言中, 变量按照储存方式分为全局变量, 全局静态变量, 局部静态变量, 自动变量, block 对它们的捕获方式如下:

• 对于全局变量和所有静态变量, block 以引用的形式进行捕获
• 对于自动变量, block 进行值捕获, 即复制自动变量的副本

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
int global = 0;
static int static_global = 10;

void foo() {
    static int static_local = 100;
    int local = 1000
    void (^block)(void) ^ {
        cout << global << ", " << static_global << ", " << static_local << ", " << local << endl;
    };
    ++global;
    ++static_global;
    ++static_local;
    ++local;
    block();
}

运行foo()后, 除了local之外, 其他变量都为原来值加一, 因为只有自动变量没有进行值引用. 在 block 中, 自动变量是复制到 block 中进行储存的, 而其他种类的变量以指针的形式进行调用. 同时, 复制到 block 中的自动变量无法修改, 如果要用 block 修改外部的自动变量, 可以在声明自动变量时, 使用__block标识符:

 1
 2
 3
 4
 5
__block int local = 10;

void (^block)(void) ^ {
    ++local;
}

这样就可以修改外部的自动变量local. 可以看出, swift 中的闭包默认的捕获行为与自动变量加了__block的 block 相同.

block 也是对象

和上一篇 swift 中的闭包一样, 也就是说 block 也是引用类型, 同样可能会发生循环引用问题, 原理和处理方式同闭包类似, 不过多介绍了.

block 储存方式

在C语言中, 存储区分为字面区, 全局区, 栈区和堆区, 字面区储存的都是常量所以不能储存 block, 不过其他位置都可以, 也就是说 block 有三种储存形式, 全局block(_NSConcreteGlobalBlock), 栈block(_NSConcreteStackBlock)和堆block(_NSConcreteMallocBlock). 分辨规则如下:

• 没有使用外部捕获的自动变量的 block 均为全局block
• 其他情况定义的 block 类型与相应位置定义的变量类型一致

国为栈block在离开作用域后会和栈变量一样释放内存, 所以在非 ARC 环境下涉及栈block的赋值要小心处理.

ARC 下的 block

上面提了非 ARC 环境下栈block可能会出现空指针问题, 也就是说 ARC 会对block对象进行其他处理. 在 objc 中, 可以调用[block copy]创建一个堆block, 对于栈block, 调用copy方法会将它复制到堆上, 而对于堆block, 调用copy方法不会再进行复制, 而只是将引用计数加一.

和自动插入retain, release一样, ARC 会适当地在代码中插入copy, 当把栈block赋值给强引用对象(__strong)或者作为函数返回值时, 会自动进行 cpoy, 在调用 gcd 之类的 cocoa 框架时, 也会复制 block. 考虑下面的例子:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
void (^block[5])(void);

for (int i = 0; i < 5; ++i) {
    block[i] = ^ {
        cout << i + 1 << endl;
    };
}

for (int i = 0; i < 5; ++i) {
    block[i]();
}

在 MRC 下, 输出值是五排5, 并且因为栈block实际已经释放了, 只是那块内存还没有被使用上, 所以没报错. 而在 ARC 下, 因为数组block默认是强引用对象, 所以在第一个循环中会将栈block复制到堆上再赋给block数组, 输出结果就是1 2 3 4 5.

block 的实现

了解 block 的实现对理解 block 行为有很大帮助, 使用 clang 可以将含 block 的代码转换成 C++ 源码, 可以从中看出 block 的具体实现. 不过我这里就不看了, 定性了解就好orz

block 本质是对象

上面也说了, 这很好理解, block 对象中也包含了捕获的自动变量, 没有使用的变量不会出现在对象中. 因为实际上 objc, C++ 的类都可以翻译成C语言的结构体, block 也不例外, 所以 block 的调用实际上也是类似于函数指针一样的调用.

block 捕获的变量

block 使用值复制的方式捕获自动变量, 使用指针方式捕获静态变量和全局变量, 在自动变量声明前加入__block后, 自动变量的声明也会变成结构体, 也就是原来的自动变量也变成了一个对象, block 中包含对这个对象的引用, 这样就可以在 block 中修改外部的自动变量.

block 的复制

调用copy方法会复制 block, 那么在对栈block进行复制时, 会在栈和堆上出现两个一样的 block, 如何判断调用时使用哪个 block? 在 block 结构体中, 有一个__forwarding变量, 它通常指向 block 自身, 在对栈block复制时, 栈block的__forwarding会指向堆block, 这样就能保证任何时候都可以访问同一个 block.

block 中对象的所有权

在引用计数中, A 对 B 的所有权代表 A 是否会改变 B 的引用计数. 看一个在 ARC 环境下的例子:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
void (^block)(id);
{
    id array = [[NSMutableArray alloc] init];
    block = ^(id object) {
        [array addObject: object];
        cout << "array count: " << [array count] << endl;
    };
}
block([[NSObject alloc] init]);
block([[NSObject alloc] init]);
block([[NSObject alloc] init]);

输出为:

 1
 2
 3
array count: 1
array count: 2
array count: 3

正常情况array在离开作用域后会立刻析构, 但上面的例子看起来是在block未析构时, array也未析构. 首先array是自动变量, 可以看作是一个NSMutableArray的指针, 在block捕获它时, 是进行值复制的. array是默认的强引用类型, 所以有复制的时候, 复制的值也是强引用, 也就是说在捕获的同时, block也拥有了array的所有权, 所以即使当array离开作用域 release 之后, block扔持有array指向的NSMutableArray. 如果在array前加入__block也一样, 只不过可以进一步修改array的指向.

注意的是 block 对对象的持有是对于强引用的, 对于弱引用, 为了不破坏弱引用的意义, block 不会持有弱引用所指向的对象. 比如下面的输出就都是0:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
void (^block)(id);
{
    id array = [[NSMutableArrayalloc] init];
    id __weak weakArray = array;
    block = ^(id object) {
        [weakArray addObject: object];
        cout << "array count: " << [weakArray count] << endl;
    };
}
block([[NSObject alloc] init]);
block([[NSObject alloc] init]);
block([[NSObject alloc] init]);

目录

• 闭包表达式的基本形式
• 闭包中默认捕获的是变量的引用
  • 被捕获的是值类型
  • 被捕获的是引用类型
  • 引用是可以修改外部变量的
• 闭包引起的循环引用
  • 闭包本身是引用类型
  • 闭包对引用类型本身的引用是怎么释放的
  • 闭包的引用循环
• 总结

闭包表达式的基本形式

 1
 2
 3
{ [copyItem = item, anotherItem, unkonwn self] (paraA: Int, paraB: String) -> String in
    // some code
}

随便写了一个, 一个完整没有简写的闭包包括捕获列表, 参数类型和返回值, 参数和返回值与普通函数差不多, 就不提了. 捕获列表中可以为被捕获的值起一个别名, 也可以直接直接使用原来的名称(但实际上是闭包外变量的一个拷贝), 为了防止循环引用, 可以在被捕获的引用变量前加weak, unknown等修饰.

闭包中默认捕获的是变量的引用

为了下面方便演示, 首先定义下面这个延迟函数:

 1
 2
 3
 4
 5
 6
func delay(_ time: Int = 2, @escaping closure: () -> ()) {
    DispatchQueue.main.asyncAfter(deadline: .now() + DispatchTimeInterval.seconds(time)) {
        print("colsure start execute")
        colsure()
    }
}

这个函数要把传入的闭包延迟两秒执行, 因为在函数执行后才执行闭包, 所以使用@escaping来修饰闭包. emmmm没搞清 playground 里怎么弄延迟, 所以还是用iOS程序来运行吧.

被捕获的是值类型

 1
 2
 3
 4
 5
var a = 0
delay {
    print("a = \(a)")
}
a = 10

输出为:

 1
 2
closure start execute
a = 10

可以发现闭包并没有把a的值复制下来, 而是直接捕获了它的引用, 在闭包执行前修改a, 执行闭包的时候通过引用找到现在a的值, 打印10.

如果使用捕获列表, 那么就会在闭包内对捕获列表中的值进行复制, 闭包内外的变量此时不是同一个变量了.

 1
 2
 3
 4
 5
var a = 0
delay { [copyA = a] in
    print("a = \(copyA)")
}
a = 10

输出为:

 1
 2
closure start execute
a = 0

等同于下面这么写

 1
 2
 3
 4
 5
 6
var a = 0
var copyA = a // 注意这个变量只可以在闭包内访问
delay {
    print("a = \(copyA)")
}
a = 10

被捕获的是引用类型

因为闭包内捕获的是引用, 所以被捕获值本是是引用类型而言, 捕获的并不是引用的值, 而是引用类型本身的一个引用, 有点像C语言中的双重指针.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
class Person {
    var name: String

    init(name: String) {
        self.name = name
    }

    deinit {
        print("\(self.name) is dead")
    }
}

var b = Person(name: "B")
delay {
    print("the name of b is \(b.name)")
}
b = Person(name: "C")

输出为:

 1
 2
 3
 4
B is dead
closure start execute
the name of b = C
C is dead

和上面值类型的例子差不多, 因为捕获的是引用类型本身的引用, 并没有持有类本身, 所以当给b赋给其他值的时候, person B引用计数为0, 进行了析构. 闭包调用的时候, 通过变量b的引用找到了b本身, 再跟据b找到了person C实例, 输出结果.

如果使用捕获列表, 情况就不一样了, 因为捕获列表是复制一份值到闭包内, 所以闭包内的复制变量会持有类实例的强引用.

 1
 2
 3
 4
 5
var b = Person(name: "B")
delay { [copyB = b]
    print("then name of b is \(b.name")
}
b = Person(name: "C")

输出为:

 1
 2
 3
 4
closure start execute
the name of b is B
B is dead
C is dead

因为闭包里的copyB就是b的复制, 而不是值引用, 所以同样可以对类实例保留强引用.

引用是可以修改外部变量的

最后, 因为捕获的是引用, 所以如果不是使用捕获列表复制变量的话, 闭包内部是可以修改外部被捕获的变量的

 1
 2
 3
 4
 5
var a = 0
delay {
    a = 10
}
print("a = \(a)")

输出为:

 1
 2
closure start execute
a = 10

闭包引起的循环引用

闭包本身是引用类型

因为函数, 或者闭包在 swift 中是一等值, 所以闭包是可以以赋值的形式传来传去的, 在传递的过程中, 闭包本身没有进行复制, 传值传的只是闭包自身的引用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
func makeIncrease(_ num: Int) -> () -> Int {
    var base = 0
    let closure =  {
        base += num
        return base
    }
    return closure
}

let increase = makeIncrease(10)
increase()
// 10
increase()
// 20
let anotherIncrease = increase
anotherIncrease()
// 30

函数makeIncrease返回一个闭包, 每执行一个这个闭包, 返回值增加num. 可以看出当把闭包由increase传给anotherIncrease时, 还是同一个闭包, 说明传递的只是闭包的引用.

闭包对引用类型本身的引用是怎么释放的

说起来比较绕口, 还是用上面闭包捕获引用类型的例子来说明, 为了更清晰地看出引用类型什么时候脱离作用域进行析构, 我们把代码放在函数里:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
class Person {
    var name: String
    init(name: String) {
        self.name = name
    }
}

func demo() {
    var b = Person(name: "B")
    delay {
        print("the name of b is \(b.name)")
    }
    b = Person(name: "C")
}

demo()

输出为:

 1
 2
 3
 4
B is dead
closure start execute
the name of b is C
C is dead

开始的时候并没有说最下面的一行输出是怎么回事, 当离开demo的作用域时(此时闭包还没有执行), person C并没有析构, 因为引用类型变量b还在被闭包引用着, 而b保留着对person C的引用, 所以直到闭包运行结束之后, 变量b脱离作用域, person C引用计数为0, 进行析构.

闭包的引用循环

因为闭包本身是引用类型, 可以被类或其他闭包引用; 而闭包本身可以引用类或者其他闭包, 这就可以会构成引用循环

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
class Person {
    var name: String

    lazy var introduce: () -> String = {
        let str = "my name is \(self.name)"
        return str
    }

    init(name: String) {
        self.name = name
    }
}

var a = Person(name: "A")
a.introduce()
// my name is A
a.introduce = {
    let str = "I am a person"
}
a.introduce()
// I am a person

introduce是类Person的一个变量, 它是一个闭包, 将它声明为懒加载是因为它引用了self, 而懒加载可以保证只有当self初始化结束, 并且self存在的时候才可以调用这个变量.

可以看出, 闭包中引用了self, 也就是说闭包有对self的强引用; 而闭包本身又是self的一个变量, 即self又强引用了闭包, 这就造成了循环引用, 可以使用unknown, weak来修饰这个闭包变量, 或者, 因为我们是在讲闭包, 所以可以在捕获列表中使用unknown, weak来避免循环引用:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
class Person {
    var name: String

    lazy var introduce: () -> String = { [unknown self] in
        let str = "my name is \(self.name)"
    }

    init(name: String) {
        self.name = name
    }
}

因为类实例析构的时候闭包肯定也不在了, 而使用闭包的时候类一定还在, 所以可以保证在使用期间self不会为nil, 在捕获进闭包时使用unknown修饰self就可以了.

总结

看这些例子还是有点绕, 其实总结起来注意几点就好:

• 闭包默认捕获的是值的引用
• 如果是引用类型的值, 闭包捕获的是这个引用的引用
• 捕获列表里捕获的是复制进来的值, 而不是引用
• 闭包本身也是引用类型

目录

• 直接用原来的 sqlite 文件不行么
• 用得到的 Core Data API
• 问题解决

直接用原来的 sqlite 文件不行么

不行, 亲测!

如果进到 Core Data 保存的目录下可以看到, 除了 sqlite 文件之外, 还会有预写式日志文件(.whl)和共享内存文件(.shm), 当前的数据可能还在读写, 或许有些还没有写入 .sqlite 文件, 所以仅仅复制 .sqlite 文件是不可取的, 并且 .whl 和 .shm 文件也不好处理. 最好是可以找到 Core Data 自身的相关 API.

用得到的 Core Data API

看向 Core Data 栈的底层, 可以发现NSPersistentCoordinator类下有一个migratePersistentStore(_:to:options:withType:)方法, 该方法会把传入的NSPersistentStore文件复制到所传入的新 URL 的位置, 正是我们想要的 API.

不过这个 API 本来是用于转移数据位置的, 会导致原来的NSPersistentCoordinator移掉这个NSPersistentStore. 我们想要的功能仅仅是把数据复制一下, 而原来的 Core Data 继续生效, 所以还需要再创建一个临时的NSPersistentCoordinator指向这个NSPersistentStore.

也就是说, 我们要在一个NSPersistentStore上建立两个NSPersistentCoordinator, 为了不对原来的 Core Data 产生影响, 并且也没有干预原来数据的必要, 我们要设置这个临时的NSPersistentcoordinator对NSPersistentStore为只读. 同时像上面说的, .whl 和 .shm 文件不好处理, 所以对于转移后的新文件, 我们要关闭日志功能.

问题解决

上代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
func backupFile() -> URL {
    // 以只有一个文件为例
    let sourceStore = persistentStores.first!
    // 使用原来的数据模型创建一个临时 NSPersistentCoordinator
    let backupCoordinator = NSPersistentStoreCoordinator(managedObjectModel: managedObjectModel)
    // 设置下面要添加 NSPersistentStore 的配置, 需要保存证为只读
    let options = (sourceStore.options ?? [:]).merging([NSReadOnlyPersistentStoreOption: true]) { $1 }
    // 将原来的 NSPerstentStore 添加进来, 除了配置之外, 其他参数都使用原来的即可
    let backupStore = try! backupCoordinator.addPersistentStore(ofType: sourceStore.type,
                                                                configurationName: sourceStore.configurationName,
                                                                at: sourceStore.url,
                                                                options: options)
    // 设置下面转移文件的配置, 还是设置为只读, 而且关闭日志, 在转移的时候整理原来的数据碎片
    let backupStoreOptions: [AnyHashable: Any] = [NSReadOnlyPersistentStoreOption: true,
                                                  NSSQLitePragmasOption: ["journal_mode": "DELETE"],
                                                  NSSQLiteManualVacuumOption: true]
    // 提供数据要转换到的 URL
    let url = generateUniqueURL()
    // 转移数据, 并且指定一下保存为 sqlite 文件
    try! backupCoordinator.migratePersistentStore(backupStore,
                                                  to: url,
                                                  options: backupStoreOptions,
                                                  withType: NSSQLiteStoreType)
    return url
}

最后别放了使用之后处理一下生成和备份文件.

目录

• 接下来一直用这个例子
• 使用 Promise 解开嵌套闭包
• 使用 async/await 把 Promise 变成同步代码

接下来一直用这个例子

比如我们要登录网站取得用户的信息, 需要三个步骤:

• 取得登录 token

• 登录通过用户验证

• 取得信息

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
let url = URL(string: "https://theurl.com")!
URLSession.shared.dataTask(with: url) { data, _, error in
    if let error = error {
        print(error)
        return
    }
    guard let data = data else {
        return;
    }
    let token = fetchToken(data)
    let request = URLRequest(from: token)
    URLSession.shared.dataTask(with: request) { data, _, error in
        if let error = error {
            print(error)
            return
        }
        guard let data = data else {
            return;
        }
        let auth = fetchAuth(data)
        let request = URLRequest(from: auth)
        URLSession.shared.dataTask(with: request) { data, _, error in
            if let error = error {
                print(error)
                return
            }
            guard let data = data else {
                return;
                let info = fetchInfo(data);
                print(info);
            }
        }.resume()
    }.resume()
}.resume()

一共进行了三次异步请求, 因为每一步都需要上一步的数据, 所以只能把下一步的请求放在上一步请求的回调闭包中.

使用 Promise 解开嵌套闭包

在刚接触 Promise 的时候就写过一篇相关的文章, 主要是讲 Promise 内部是怎么把嵌套调用变成链式调用的, 这里主要讲一下 Promise 的思想.

在异步调用的回调函数中, 我们要处理两种情况: 回调成功和失败, 如果回调成功, 回调函数中应该会有一个我们希望得到的一个传入参数; 失败的话会传入一个Error. 也就是说, 回调函数的传入参数可以是一个枚举:

 1
 2
 3
 4
enum result {
    case success(WishType)
    case failed(Error)
}

Promise 把这个过程封装了起来, 它允许传入两个函数, 对应着回调成功和失败, 两个函数的参数分别是WishType和Error. 这两个函数是 Promise 生成的, 在使用过程用我们跟据调用是否成功来选择调用哪一个. 使用then函数可以向 Promise 添加新的异步调用, 对应着回调fullfill函数, 并再返回一个 Promise. 使用catch函数相当于传入了一个rejected函数, 进行错误处理.

then与catch的函数类型和fullfill与rejected的并不一样, Promise 内部实现了它们之前的转换. 需要注意的是, 并不是then函数触发了异步调用的开始, Promise 实例化的时候, 异步调用就已经开始了, then和catch只是指写了当 Promise 调用成功或失败后, 下一步应该做什么.(这制杖的语法高亮还把catch标红了…)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
struct Promise<WishType> {
    init(resolver: (_ fullfill: @escaping(WishType) -> Void, _ rejected: @escaping(Error) -> Void) -> Void) {
        ......
    }

    func then<NextType>(_ body: (WishType) -> NextType) -> Promise<NextType> {
        ......
    }

    func `catch`(_ body: (Error) -> Void) {
        ......
    }
}

使用 Promise, 就可以把上面例子中的多层嵌套解开了:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
let url = URL(string: "https://theurl.com")!
Promise<Data> { resolver in
    URLSession.shared.dataTask(with: url) { data, _, error in
        if let error = error {
            resolver.rejected(error)
        }
        if let data = data {
            resolver.fullfill(data)
        }
    }.resume()
}.then { data in
    let token = fetchToken(data)
    let request = URLRequest(from: token)
    return Promise<Data> { resolver in
        URLSession.shared.dataTask(with: request) { data, _, error in
            if let error = error {
                resolver.rejected(error)
            }
            if let data = data {
                resolver.fullfill(data)
            }
        }.resume()
    }
}.then { data in
    let auth = fetchAuth(data)
    let request = URLRequest(fron: auth)
    return Promise<data> { resolver in
        URLSession.shared.dataTask(with: request) { data, _, error in
            if let error = error {
                resolver.rejected(error)
            }
            if let data = data {
                resolver.fullfill(data)
            }
        }.resume()
    }
}.then { data in
    let info = fetchInfo(data)
    print(info)
}.catch { error in
    print(error)
}

可以看到之前的多重嵌套回调已经变成了链式的函数调用. 额, 变得这么长是因为定义 Promise 的写了不少…如果使用 PromiseKit, URLsession这处常用的异步函数都已经封装好了 Promise, 这里手动定义是为了更好地理解 Promise.

使用 async/await 把 Promise 变成同步代码

虽然 Promise 使得异步调用不必写多重嵌套回调, 不过这种链式函数调用的方式还是和一般的同步执行代码有一定的区别, 我们最终希望可以变成这样的同步形式的代码:

 1
 2
 3
 4
 5
 6
 7
 8
let url = URL(string: "https://theurl.com")!
let tokenData = URLSession.shared.dataTask(with: url).resume()
let token = fetchToken(tokenData)
let authData = URLSession.shared.dataTask(with: URLRequest(from: tkoen)).resume()
let auth = fetchAuth(authData)
let infoData = URLSession.shared.dataTask(with: URLRequest(from: auth)).resume()
let info = fetchInfo(infoData)
print(info)

借助 AwaitKit, 我们真的可以以这种形式来写异步代码. async/await 是基于 Promise 的, async其实就是对 Promise 进行了封装, 可以更方便地定义 Promise:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
func tokenPromise(_ url: URL)throws -> Promise<Data> {
    return async {
        URLSession.shared.dataTask(with: url) { data, _, error in
            if let error = error {
                throw error
            }
            return data!
        }.resume()
    }
}

func authPromise(_ request: URLRequest)throws -> Promise<Data> {
    return async {
        URLSession.shared.dataTask(with: request) { data, _, error in
            if let error = error {
                throw error
            }
            return data!
        }.resume()
    }
}

func infoPromise(_ request: URLRequest)throws -> Promise<Data> {
    return async {
        URLSession.shared.dataTask(with request) { data, _, error in
            if let error = error {
                throw error
            }
            return data!
        }.resume()
    }
}

再使用await函数把异步函数变为同步函数, 写出同步形式的代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
let url = URL(string: "https://theurl.com")!
do {
    let tokenData = try await(tokenPromise(url))
    let token = fetchToken(tokenData)
    let authData = try await(authPromise(URLRequest(form: token)))
    let auth = fetchAuth(authData)
    let infoData = try await(infoPromise(URLRequest(from: auth)))
    let info = fetchInfo(infoData)
    print(info)
}.catch(let error) {
    print(error)
}

可以看到调用异步函数, 处理异常都变成了同步的方式.

await 内部实现使用了信号量来阻塞线程, 使得异步调用结束之前当前线程不会向下运行:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
func await<T>(_ promise: Promise<T>)throws -> T {
    let queue = DispatchQueue(label: "await.asyncqueue", attributes: .concurrent)
    let semaphore = DispatchSemaphore(value: 0)
    let result: T?
    let error: Error?
    promise.then(on: queue) {
        result = $0
        semaphore.signal()
    }.catch(on: queue) {
        error = $0
        semaphore.signal()
    }
    _ = semaphore.wait(timeout: .distabtFuture)
    guard let result = result else {
        throw error!
    }
    return result
}

使用了数值为0的信号量阻塞当前线程, 创建了一个后台线程来运行异步调用, 异步回调运行结束的时候再解开信号量. 要注意的是这里并没有用 PromiseKit 中的ensure函数保证semaphore.signal()的运行, 是因为ensure会在catch之前运行, 这样会使得线程在catch之前就解除阴塞, 无法正常抛出错误.

因为 Swift 对于解决回调地狱还没有语言层面上的支持, Promise 还好, async/await 这种还只能使用函数而不是关键字的方式来实现, 不过在未来的 Swift 5 中有望得到原生的支持.

目录

• 要使用的NSManagedObject类
• json 格式
• 自定义需要与 json 互相转换的键值
• 定义编码
• 定义解码
• 更像 Core Data 地调用

要使用的NSManagedObject类

就拿我正在写的课程表的数据模型来举例吧, 定义了下面两个NSManagedObject类:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
final class CourseData: NSManagedObject {
    @NSMananaged var name: String
    @NSManaged var teacher: String
    @NSManaged var time: Set<TimeData>?
}

final class TimeData: NSManagedObject {
    @NSManaged var place: String
    @NSManaged var startseciton: Int64
    @NSManaged var endsetion: Int64
    @NSManaged var week: Int64
    @NSManaged var teachweek: [Int64]
    @NSManaged var course: CourseData
}

就是常见的课程表数据类型, 课程与上课时间建立了一对多关系. 分成两个类一方面是因为按照上课时间排课程表, 或者显示课程详情; 另一方面也方便通过关系找到对应上课时间的课程信息. 课程类中上课时间属性是可选值, 因为有的课程可能没有上课时间.

json 格式

因为网络 api 也是我写的, 所以格式和上面基本差不多:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
{
    "name": "操作系统",
    "teacher": "teacher"
    "time": [
    {
        "place": "综一 156",
        "startsection": 3,
        "endsection": 4,
        "week": 2,
        "teachweek": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
    },
    {
        "place": "综一 156",
        "startsection": 5,
        "endsection": 6,
        "week": 5,
        "teachweek": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
    }]
}

课程名与上课时间写在了一起, 并且上课时间是一个数组, 不是上面类中定义的集合.

自定义需要与 json 互相转换的键值

可以看到CourseData与TimeData中都有代表关系的属性, 在与 json 互相转换的过程中不需要包含这两个属性. 而且因为@NSManaged的关系, 直接遵守Codable属性后也不会转换被它标记的属性, 所以要手动定义哪些属性需要被转换.

Codable协议中默认实现了CodingKey协议的枚举, 为所有的储存属性添加了键值, 因为上面提到的原因, 现在我们要手动定义这个枚举:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
// CourseData
enum CodingKeys: String, CodingKey {
    case name
    case teacher
    case time
}

// TimeData
enum CodingKeys: String, CodingKey {
    case place
    case startsection
    case endsection
    case week
    case teachweek
}

需要注意的是目前Codable协议无法应用到类的 extension 中, 所以只能在类定义内添加协议要求的方法. 在文章的最后我会放上完整的类定义代码.

定义编码

Codable协议由Encodable和Decodable两个协议组成, 分别对应着编码和解码, 我们先来看编码. 编码要求我们实现encode(to encoder: Encoder) throws方法. 因为CourseData中包含TimeData对象, 所以我们先实现TimeData的编码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
// TimeData
func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    try! container.encode(place, forKey: .place)
    try! container.encode(startsection, forKey: .startsection)
    try! container.encode(endsection, forKey: .endsection)
    try! container.encode(week, forKey: .week)
    try! container.encode(teachweek, forKey: .teachweek)
}

首先我们以刚才定义的键值从encoder中取得一个container, container中应该包含键值和其对应的值, 接着我们调用container的encode方法为每个键赋值, 因为TimeData中每个要编码的属性都是可编码的, 所以直接赋值即可. 为了举例方便, 我没有对可能出现的异常进行处理.

对于CourseData因为刚定义好TimeData的编码方法, 所以CourseData中的属性也都可以直接进行编码了:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
// CourseData
func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    try! container.encode(name, forKey: .name)
    try! container.encode(teacher, forKey: .teacher)
    if let time = time {
        let timeArray = Array(time)
        try! container.encode(timeArray, forKey: .time)
    }
}

如果可选值为 nil, 根据 json 的语法, 对应的键也应该没有. 在 Core Data 中关系的储存方式为集合类型, 在转换成 json 的时候要记得转换为数组.

现在我们可以直接使将这两个类转换为 json:

 1
 2
 3
let encoder = JSONEncoder()
let jsonData = try! encoder.encode(courseData)
let json = String(data: jsonData, encoding: .utf8)!

定义解码

解码协议Decodable要求实现指定初始化器init(from decoder: Decoder) throws, 但是NSManagedObject有两个指定初始化器, 要想再定义其他的初始化器必须调用这两个其中的一个, 所以需要使用一些技巧:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
// TimeData
static var context: NSManagedObjectContext!

required convenience init(from decoder: Decoder) throws {
    self.init(entity: "TimeData", insertInto: TimeData.context)
    let container = try! decoder.container(keyedBy: CodingKeys.self)
    place = try! container.decode(String.self, forKey: .place)
    startsection = try! container.decode(Int64.self, forKey: .startsection)
    endsection = try! container.decode(Int64.self, forKey: .endsection)
    week = try! container.decode(Int64.self, forKey: .week)
    teachweek = try! container.decode([Int64].self, forKey: .teachweek)
}

为了调用指定初始化器, 我们定义一一个便利初始化器, 为了传入寝室初始化器所需要的参数, 定义了一个类变量. 不过这样做会导致使用这个初始化器之前必须先修改类变量, 为了实现从 json 初始化, 也只能这么做了. 接着还是取出一个container不过这次是从里面解码出数据.

对于CourseData, 注意取出的TimeData不能直接添加到集合中, 集合是为了表示 Core Data 中的一对多关系, 由 Core Data 维护, 直接修改会导致 Core Data 错误, 正确的做法是把CourseData添加到每一个TimeData的对单关系中:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
// CourseData
static var Context: NSManagedObjectContext!

required convenience init(from decoder: Decoder) throws {
    self.init(entity: "CourseData", insertInto: CourseData.context)
    let container = try! decoder.container(keyedBy: CodingKeys.self)
    name = try! container.decode(String.self, forKey: .name)
    teacher = try! container.decode(String.self, forKey: .teacher)
    TimeData.context = CourseData.context
    if let timeArray = try? container.decode([TimeData].self, forKey: .time) {
        _ = timeArray.map { $0.course = self }
    }
}

更像 Core Data 地调用

这样我们就完成对Codable协议的实现, 不过还需要再封装一下解码方法, 因为在插入一个NSManageObject的时候要指定NSManageObjectContext, 直接调用init(from decoder: Decoder)方法可能导致忘记先给context赋值而发生程序错误. 所以我们再定义一个ManagedObject协议, 规定一下和 json 转换的接口:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
protocol ManagedObject where Self: NSManagedObject {
    static var entityName: String { get }

    static var viewContest: NSManagedObjectContext { get set }

    static func insertNewObject(from json: String, into context: NSManagedObjectContext) -> Self
    
    func exportJson() -> String
}

extension ManagedObject where Self: Codable {
    static func insertNewObject(from json: String, into context: NSManagedObjectContext) -> Self {
        let decoder = JSONDecoder()
        let jsonData = json.data(using: .utf8)!
        Self.viewContext = context
        let newObject = try! decoder.decode(Self.self, from: jsonData)
        return newObject
    }

    func exportJson() -> JSON {
        let encoder = JSONEncoder()
        let jsonData = try! encoder.encode(self)
        let json = String(data: jsonData, encoding: .utf8)!
        return json
    }
}

定义一下entityName是为了避免硬编码字符串, 不方便修改程序. 导出 json 的方法也没什么需要解释的. 从 json 新建一个NSManagedObject需要调用insertNewObject(from json: String, into context: NSManagedObjectContext)方法, 传入一个 json 的要添加到的context. 因为没什么需要在类中自定义的, 就使用协议扩展实现了默认实现.

提一下viewContext属性, 因为Codable只能在类定义中实现, 所以类定义中必须包含一个context属性. 在协议中不能调用协议中未定义的属性, 所以只好额外定义一个viewContext属性. 如果以后Codable可以应用在 extension 中, 那就可以直接让ManagedObject协议遵守Codable, 也不用这么折腾了.

两个类对协议的实现如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
// TimeData
static var entityName: String {
    return "TimeData"
}

static var viewContext: NSManagedObjectContext {
    get { return context }
    set { context = newValue }
}

// CourseData
static var entityName: String {
    return "CourseData"
}

static var viewContext: NSManagedObjectContext {
    get { return context }
    set { context = newValue }
}

最后放一下两个类的完整定义:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
final class CourseData: NSManagedObject, Codable {
    fileprivate static var context: NSManagedObjectContext!
    
    @NSManaged var name: String
    @NSManaged var teacher: String
    @NSManaged var time: Set<TimeData>?
    
    enum CodingKeys: String, CodingKey {
        case name
        case teacher
        case time
    }
    
    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try! container.encode(name, forKey: .name)
        try! container.encode(teacher, forKey: .teacher)
        if let time = time {
            let timeArray = Array(time)
            try! container.encode(timeArray, forKey: .time)
        }
    }
    
    required convenience init(from decoder: Decoder) throws {
        self.init(entity: CourseData.entity(), insertInto: CourseData.context)
        let container = try! decoder.container(keyedBy: CodingKeys.self)
        name = try! container.decode(String.self, forKey: .name)
        teacher = try! container.decode(String.self, forKey: .teacher)
        TimeData.context = CourseData.context
        if let timeArray = try? container.decode([TimeData].self, forKey: .time) {
            _ = timeArray.map { $0.course = self }
        }
    }
}

extension CourseData: ManagedObject {
    static var viewContext: NSManagedObjectContext {
        get { return context }
        set { context = newValue }
    }
    
    static var entityName: String {
        return "CourseData"
    }
}

final class TimeData: NSManagedObject, Codable {
    fileprivate static var context: NSManagedObjectContext!
    
    @NSManaged var place: String
    @NSManaged var startsection: Int64
    @NSManaged var endsection: Int64
    @NSManaged var week: Int64
    @NSManaged var teachweek: [Int64]
    @NSManaged var course: CourseData
    
    enum CodingKeys: String, CodingKey {
        case place
        case startsection
        case endsection
        case week
        case teachweek
    }
    
    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: CodingKeys.self)
        try! container.encode(place, forKey: .place)
        try! container.encode(startsection, forKey: .startsection)
        try! container.encode(endsection, forKey: .endsection)
        try! container.encode(week, forKey: .week)
        try! container.encode(teachweek, forKey: .teachweek)
    }
    
    required convenience init(from decoder: Decoder) throws {
        self.init(entity: TimeData.entity(), insertInto: TimeData.context)
        let container = try! decoder.container(keyedBy: CodingKeys.self)
        place = try! container.decode(String.self, forKey: .place)
        startsection = try! container.decode(Int64.self, forKey: .startsection)
        endsection = try! container.decode(Int64.self, forKey: .endsection)
        week = try! container.decode(Int64.self, forKey: .week)
        teachweek = try! container.decode([Int64].self, forKey: .teachweek)
    }
}

extension TimeData: ManagedObject {
    static var viewContext: NSManagedObjectContext {
        get { return context }
        set { context = newValue }
    }
    
    static var entityName: String {
        return "TimeData"
    }
}

Use Core Data, SQLite, or Posix locks to help coordinate data access in a shared container.

不同于UserDefaults, Core Data 中并没有直接使用 Group Identifier 初始化的方法, 网上资料也很少, 记录一下.

目录

• 默认的 Core Data 初始化
• NSPersistentContainer隐藏了什么
• 把 Core Data 存到 App Group 中
• EX: Core Data是怎么实际储存在设备上的

默认的 Core Data 初始化

如果在创建 target 的时候勾选了 Core Data 选项, xcode 会为我们的项目自动添加上 Core Data 相关的代码, 包括xcdatamodeld数据模型文件和 Core Data Stack 初始化相关的代码. AppDelegate中会多出一个persistentContainer属性:

 1
 2
 3
 4
 5
 6
 7
 8
 9
lazy var persistentContainer: NSPersistentContainer = {
    let container = NSPersistentContainer(name: "test")
    container.loadPersistentStores(completionHandler: { (storeDescription, error) in
        if let error = error as NSError? {
            fatalError("Unresolved error \(error), \(error.userInfo)")
        }
    })
    return container
}()

使用了一个闭包来初始化这个 lazy 属性, 首先实例化了一个NSPersistentContainer, 其中的 name 值是我们创建xcdatamodeld的文件名, 系统会根据这个文件所定义的模型来创建数据模型, 然后以这个名字在 Main Bundle 中创建数据文件, 我们进行数据的增删改查时所使用的NSManagedObjectContext类由这个persistentContainer的viewContext属性获得.

可以看出这样创建的 Core Data Stack 只能在 Main Bundle 中建立数据文件, 无法在 App Group 中共享.

NSPersistentContainer隐藏了什么

NSPersistentContainer这个类其实是为了使 Core Data 的使用变得更加简单, 它隐藏了很多 Core Data 初始化的细节, 我们来看一下 Core Data Stack 中各个类之间的关系(图片来自于 Core Data):

从底向上看, 数据的储存形式可以是 sqlite, xml 或者是内存, 我们不会手动创建它们, 而是使用NSPersistentStore这个类来进行初始化, 也就是图中的持久化储存.

持久化储存上面一层是持久化储存协调器, 用NSPersistentCoordinator类来代表, 它负责协调底层的持久化储存和上层的托管对象上下文, 从持久化储存中取出数据线给上下文, 或者将上下文中的改动储存至持久化储存.

再向上就是我们常用的托管对象上下文和托管对象了, 分别是NSManagedObjectContext和NSManagedObject, 对托管对象的增删改查都是对托管对象上下文进行操作.

除了这些类, 还有一个NSManagedObjectModel, 用于管理托管对象的模型, 我们所创建的xcdatamodeld文件就是用于初始化这个类的. 如果想在其他的 target 中也使用同一个模弄文件, 需要在 Target Membership 中勾选想要添加的 target:

把 Core Data 存到 App Group 中

这样看来, 涉及到的文件只有两个, 模型文件和数据文件. 模型文件我们可以直接添加到每个 target 中, 而数据文件是使用NSPersistentSrore来创建的, 所以就不能使用NSPersistentContainer来初始化 Core Data , 需要手动创建整个 Core Data Stack.

 1
 2
 3
 4
 5
 6
 7
 8
let bundle = Bundle(for: DataManager.self)
let model = NSManagedObjectModel.mergedModel(from: [bundle])!
let coordinator = NSPersistentStoreCoordinator(managedObjectModel: model)
let groupURL = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: "group.test.shino.space")!
let url = groupURL.appendingPathComponent("data.data")
try! coordinator.addPersistentStore(ofType: NSSQLiteStoreType, configurationName: nil, at: url, options: nil)
let context = NSManagedObjectContext(concurrencyType: .mainQueueConcurrencyType)
context.persistentStoreCoordinator = coordinator

首先是初始化数据模型, 模型文件在项目的 mainbundle 或者是 extension 的 bundle 中, 所以使用Bundle(for: AnyClass)来获取, 再使用这个模型来初始化待久化储存协调器. 对于持久化储存, 它的初始化需要提供一个 url, 我们使用 App Group Identifier 创建一个 url 给它, 数据文件的名字为data.data. 把创建好的持久化储存赋给持久化储存协调器. 最后我们创建一个托管对象上下文, 把这个上下文赋给持久化储存协调器, Core Data Stack 就设置好了, 我们在这个上下文上进行操作的数据就会保存在 App Group 中

EX: Core Data是怎么实际储存在设备上的

自己手机越狱装了 Filza, 所以顺便看了看文件具体的储存情况. 我在项目的主项目, today extension 和 watch extension 中都添加了 Core Data , 所以这三个 bundle 中都在模型文件, 路径分别为:

 1
 2
 3
 4
 5
/var/Containers/Bundle/Application/你的 App 文件夹

/var/Containers/Bundle/Application/你的 App 文件夹/Plugins/你的 App Extension 文件夹

/var/Containers/Bundle/Application/你的 App 文件夹/Watch/你的 Watch App 文件夹/Plugins/你的 Watch App Extension 文件夹

实际储存的模型文件名字不变, 后缀名变为.momd.

而数据是存在 App Group 中的, 因为共享, 所以只有一个. 注意现在的 watch app 已经变为了独立的 app, 虽然可以和手机 app 使用一个 group identifier, 但是储存是分开的, 数据储存在手表上. 手机上的 Core Data 数据文件路径如下:

 1
/var/mobile/Containers/Shared/AppGroup/你的 APP 文件夹

数据文件的名称与定义的名称相同.