diff --git a/notes/学习路线 - 零基础.md b/notes/学习路线 - 零基础.md
index 71d657dd..f8060f0c 100644
--- a/notes/学习路线 - 零基础.md
+++ b/notes/学习路线 - 零基础.md
@@ -71,7 +71,7 @@
* [参考资料](#参考资料)
-适合没有学过计算机课程的读者,不需要会编程。全篇用一次手机下单的例子,讲数据怎样表示、程序怎样运行、操作系统做什么、请求怎样通过网络送达、订单怎样存进数据库,以及常用的数据结构。文中的命令可以在 macOS 和 Ubuntu 的终端中直接运行,每章末尾链接了讲得更深入的笔记。
+适合没有学过计算机课程的读者,不需要会编程。全篇用一次手机下单的例子,讲数据怎样表示、程序怎样运行、操作系统做什么、请求怎样通过网络送达、订单怎样存进数据库,以及常用的数据结构。文中的命令可以在 macOS 和 Ubuntu 的终端中直接运行。终端是输入命令的窗口:macOS 在聚焦搜索(Spotlight)中输入“终端”或 Terminal 打开,Ubuntu 按 Ctrl + Alt + T 打开。每章末尾链接了讲得更深入的笔记。
## 一、总览:一次下单经过了什么
@@ -132,7 +132,7 @@ echo 'obase=2; 1024' | bc
10000000000
```
-macOS 自带 bc;Ubuntu 上提示找不到 bc 时,先执行 sudo apt install bc 安装。
+echo 输出 `obase=2; 1024` 这行文字,竖线 | 把它交给计算器程序 bc;obase=2 让 bc 用二进制输出,1024 是要换算的数。macOS 自带 bc;Ubuntu 上提示找不到 bc 时,先执行 sudo apt install bc 安装。
二进制写起来太长,所以常用十六进制(0~9 和 a~f,a~f 表示 10~15,逢十六进一)表示,每个十六进制数字正好对应 4 位,两个数字对应一个字节。1024 的二进制按 4 位一组是 0100 0000 0000,十六进制是 0x400(前缀 0x 表示十六进制),一个字节的取值范围写成 00~ff。
@@ -168,7 +168,7 @@ awk 'BEGIN { print (1.10 + 2.20 == 3.30) }'
所以金额不用浮点数保存,常见的做法有两种:
- 以分为单位用整数保存,28.50 元存为 2850,加减乘都是精确的整数运算,显示时再除以 100;
-- 使用十进制定点数,例如 MySQL 的 DECIMAL(10, 2)、Java 的 BigDecimal,它们按十进制保存每一位,不产生二进制的舍入误差。
+- 使用能精确表示十进制小数的类型,例如 MySQL 的 DECIMAL(10, 2)(共 10 位数字,其中 2 位在小数点后)、Java 的 BigDecimal,它们记录的是十进制的数字和小数位数,例如 BigDecimal 把 28.50 记成整数 2850 和 2 位小数,不产生二进制的舍入误差。
本篇后面都按第一种做法,把金额写成 2850 分。
@@ -249,7 +249,7 @@ printf '宫保鸡丁' | od -An -tx1
参考要点
-1. float、double 是二进制浮点数,0.1、1.10 这类小数在二进制中无限循环,只能存近似值;1.10 + 2.20 得到 3.3000000000000003,与 3.30 不相等,大量订单累加对账时会差一分钱;金额应以分为单位存成整数(28.50 元存为 2850),或用 MySQL 的 DECIMAL、Java 的 BigDecimal 这类十进制定点数。
+1. float、double 是二进制浮点数,0.1、1.10 这类小数在二进制中无限循环,只能存近似值;1.10 + 2.20 得到 3.3000000000000003,与 3.30 不相等,大量订单累加对账时会差一分钱;金额应以分为单位存成整数(28.50 元存为 2850),或用 MySQL 的 DECIMAL、Java 的 BigDecimal 这类能精确表示十进制小数的类型。
2. UTF-8 中常用汉字占 3 个字节,“宫保鸡丁”共 12 个字节;乱码是因为写入和读取用了不同的编码,例如按 UTF-8 写入、按 GBK 读取,字节被切成另外几个字,显示为“瀹繚楦′竵”;全程统一使用 UTF-8 即可避免。
3. 小端序(Little-Endian)把多字节数据的低位字节放在前面,大端序(Big-Endian)把高位字节放在前面;例如 8 字节的 1024,小端序是 00 04 00 00 00 00 00 00,大端序是 00 00 00 00 00 00 04 00;x86 和 ARM 处理器都用小端序。
@@ -379,7 +379,7 @@ od -A x -t x1 -N 16 /bin/ls
预期:Ubuntu 上开头是 7f 45 4c 46,后三个字节是字母 ELF,即 Linux 的可执行文件格式;macOS 上输出的地址和间距略有不同,开头是 ca fe ba be,表示多架构文件,里面装着 x86 和 ARM 两份 Mach-O 格式的程序。
-综合题:订单 1024 的金额 28.50 元和菜名“宫保鸡丁”在内存中各占几个字节、是什么样子?服务器上的订单程序从磁盘上的一个文件,到 CPU 执行扣库存的指令,经过了哪些步骤?(见[一个订单在内存中的样子](#一个订单在内存中的样子)、[CPU、内存与磁盘](#cpu内存与磁盘)、[从程序到进程](#从程序到进程))
+综合题:订单 1024 的金额 28.50 元和菜名“宫保鸡丁”在内存中各占几个字节、是什么样子?服务器上的订单程序从磁盘上的一个文件,到 CPU 执行扣库存的指令,经过了哪些步骤?(见[一个订单在内存中的样子](#一个订单在内存中的样子)、[CPU、内存与磁盘](#cpu内存与磁盘)、[指令](#指令)、[编译与解释](#编译与解释)、[从程序到进程](#从程序到进程))
答题思路
@@ -445,7 +445,7 @@ od -A x -t x1 -N 16 /bin/ls
进程与线程的区别可以归纳为:
- 进程是资源分配的单位,拥有独立的内存;线程是 CPU 调度的单位,同一进程的线程共享内存;
-- 创建和切换线程比进程开销小,因为不用切换内存的映射;
+- 创建和切换线程比进程开销小,因为同一进程的线程共用一套虚拟内存:创建线程不用建立新的地址空间,只要分配它自己的栈、准备好程序计数器和寄存器的初始值,同一进程的线程之间切换时也不用更换地址的翻译方式;
- 一个线程出错(例如非法访问内存)可能导致整个进程退出,而一个进程崩溃不影响其它进程。
线程虽然比进程轻,但创建和销毁仍有开销,每个线程还要占用一份栈的内存。所以实际的服务程序通常预先创建一组线程反复使用,称为线程池:请求到达时交给一个空闲的线程,处理完后线程回到池中等待下一个请求,请求多于线程数时在队列中排队。
@@ -533,15 +533,15 @@ Ubuntu 的 top 默认按 CPU 占用从高到低排序,macOS 默认按进程号
参考要点
-1. 进程是资源分配的单位,有独立的内存;线程是 CPU 调度的单位,同一进程的线程共享代码、数据和打开的文件,各自只有程序计数器、寄存器和栈(保存函数调用中的临时数据);创建、切换线程比进程开销小,因为不用切换内存的映射;一个线程出错可能导致整个进程退出,一个进程崩溃不影响其它进程。
-2. 上下文切换指进程的时间片用完或要等待数据时,操作系统保存它的寄存器,恢复下一个进程的寄存器让它运行,靠它让进程轮流使用 CPU,每个运行几毫秒;并发是靠快速切换让很多进程看起来同时运行,并行是多个 CPU 核心在同一时刻真正各运行一个。
+1. 进程是资源分配的单位,有独立的内存;线程是 CPU 调度的单位,同一进程的线程共享代码、数据和打开的文件,各自只有程序计数器、寄存器和栈(保存函数调用中的临时数据);创建、切换线程比进程开销小,因为同一进程的线程共用一套虚拟内存:创建线程不用建立新的地址空间,只要分配它自己的栈、准备好程序计数器和寄存器的初始值,同一进程的线程之间切换时也不用更换地址的翻译方式;一个线程出错可能导致整个进程退出,一个进程崩溃不影响其它进程。
+2. 上下文切换指进程分到的一小段 CPU 时间用完或要等待数据时,操作系统保存它的寄存器,恢复下一个进程的寄存器让它运行,靠它让进程轮流使用 CPU,每个运行几毫秒;并发是靠快速切换让很多进程看起来同时运行,并行是多个 CPU 核心在同一时刻真正各运行一个。
3. stock = stock - 1 分为读、算、写几条指令,两个线程卖最后一份时可能都读到 1,各自减为 0 后写回,卖出两份库存只减了 1;解决办法是加锁(Lock):一个线程在读、算、写期间持有锁,另一个线程等它释放后才能开始,让这几步作为一个整体执行;持有锁时先判断库存大于 0 再扣减,后拿到锁的线程读到 0 就提示售罄。
动手:执行 ps -ef | head -5 和 top(macOS 上用 top -o cpu),找出占用 CPU 最多的进程;在 top 开头找到进程总数(macOS 在第一行,Ubuntu 在第二行的 Tasks),对照[进程](#进程)一节理解为什么进程数远多于 CPU 核心数。
-预期:ps -ef 每行一个进程,PID 是进程号,PPID 是父进程号,CMD 是启动命令;按 CPU 排序后排在最前的就是占用最多的进程;macOS 的 top 第一行显示一千多个进程、一万多个线程(笔记实测 10 核的机器上 1091 个进程、11019 个线程),其中只有几个在运行,其余在休眠,靠轮流使用 CPU 共享少数核心。
+预期:ps -ef 每行一个进程,PID 是进程号,PPID 是父进程号,CMD 是启动命令;按 CPU 排序后排在最前的就是占用最多的进程;macOS 的 top 第一行显示几百到一千多个进程、几千到一万多个线程,数量随开着的程序变化(笔记实测 10 核的机器上 1091 个进程、11019 个线程),其中只有几个在运行,其余在休眠,靠轮流使用 CPU 共享少数核心。
明天:第 5 天,读[系统调用](#系统调用)、[文件](#文件)、[在终端中查看进程](#在终端中查看进程)。
@@ -559,14 +559,14 @@ Ubuntu 的 top 默认按 CPU 占用从高到低排序,macOS 默认按进程号
参考要点
1. 用户态是普通程序的运行状态,只能执行计算、读写自己内存这类普通指令;内核态是操作系统内核的运行状态,可以执行所有指令、直接操作磁盘和网卡;读写文件要操作磁盘,普通程序没有这个权限,要通过系统调用请内核代办:CPU 切换到内核态执行内核代码,完成后切回用户态;这样由内核统一分配硬件、隔离进程,避免程序之间互相冲突。
-2. 每个进程有独立的虚拟内存,不能直接读写别的进程的数据,要借助操作系统提供的进程间通信方式:管道、共享内存和网络连接(套接字);网络连接还能跨机器使用,订单服务和 MySQL 就通过网络连接交换数据。
+2. 每个进程有独立的虚拟内存,不能直接读写别的进程的数据,要借助操作系统提供的进程间通信方式,例如管道、共享内存和网络连接(套接字);网络连接还能跨机器使用,订单服务和 MySQL 就通过网络连接交换数据。
3. 文件描述符是程序打开文件时内核返回的一个小整数,之后的读写都用它指代这个文件;例如 openat 返回 5,write(5, ...) 就是写这个文件;网络连接也用文件描述符表示,accept4 返回的 4 就是与 App 之间的连接。
动手:在 Ubuntu 上执行 strace -e trace=write echo "order 1024"(没有 strace 时用 sudo apt install strace 安装),说明 write 的第一个参数和返回值的含义;再执行 ls -l /proc/self/fd,看看一个进程默认打开了哪些文件描述符。macOS 没有 strace 和 /proc,strace 部分对照[系统调用](#系统调用)一节的输出回答,文件描述符改用 ls -l /dev/fd 查看。
-预期:输出 write(1, "order 1024\n", 11) = 11:第一个参数 1 表示标准输出(屏幕),返回值 11 表示写入了 11 个字节;/proc/self/fd 中通常有 0、1、2 三个(标准输入、标准输出、标准错误,在终端中都指向 /dev/pts/0 这类终端设备),以及 ls 读取这个目录时自己打开的 3;macOS 上能看到名为 0、1、2 的三个条目,分别是标准输入、标准输出和标准错误,后面的 3、4 是 ls 自己打开的。
+预期:输出 write(1, "order 1024\n", 11) = 11,echo 输出的 order 1024 会夹在这条记录中间:第一个参数 1 表示标准输出(屏幕),返回值 11 表示写入了 11 个字节;/proc/self/fd 中通常有 0、1、2 三个(标准输入、标准输出、标准错误,在终端中都指向 /dev/pts/0 这类终端设备),以及 ls 读取这个目录时自己打开的 3;macOS 上能看到名为 0、1、2 的三个条目,分别是标准输入、标准输出和标准错误,后面的 3、4 是 ls 自己打开的。
明天:第 6 天,Linux 常用命令。
@@ -600,7 +600,7 @@ Ubuntu 的 top 默认按 CPU 占用从高到低排序,macOS 默认按进程号
答题思路
-1. 订单服务预先创建一组线程(线程池),每个请求交给一个空闲的线程,请求多于线程数时在队列中排队;
+1. 每个请求交给一个线程处理:实验中的订单服务为每个连接新建一个线程(每次 curl 只在一个连接上发一个请求),实际的服务程序通常预先创建一组线程反复使用(线程池),请求多于线程数时在队列中排队;
2. 线程等待数据库、网络时处于阻塞状态,CPU 转去执行其它就绪的线程,多个核心并行运行,每个核心上的线程轮流使用 CPU(上下文切换),所以 100 个请求看起来同时被处理;
3. 两个线程同时扣最后一份宫保鸡丁时,读、算、写交错执行,都读到 1、都写回 0,卖出两份库存只减 1,需要加锁,让读、算、写作为一个整体执行,并在锁内先判断库存大于 0(数据库中的做法在[事务](#事务)一节讲);
4. 接收请求(accept4、recvfrom)、写日志(openat、write、close)、发送响应(sendto)都是系统调用,CPU 切换到内核态,由内核的网络协议栈和文件系统完成,订单程序自己只做计算。
@@ -622,7 +622,7 @@ App 要把请求送到服务器,首先要知道送到哪里。网络中用两
一台服务器的 443 端口可以同时和成千上万个 App 通信,是因为一个连接由 4 个数共同确定:客户端 IP、客户端端口、服务器 IP、服务器端口。两个用户的手机地址或端口不同,就是两个不同的连接,操作系统据此把收到的数据分给对应的连接。
-IPv4 地址是 4 个字节,写成用点分开的 4 个十进制数,每个 0~255。家里的手机和电脑拿到的通常是 192.168 开头的私有地址,例如 192.168.1.10,它只在家庭网络内有效;访问互联网时,路由器把它替换成运营商分配的公网地址,这称为网络地址转换(NAT)。查看本机在局域网中的地址:
+IPv4 地址是 4 个字节,写成用点分开的 4 个十进制数,每个 0~255。家里的手机和电脑拿到的通常是 192.168 开头的私有地址,例如 192.168.1.10,它只在家庭网络内有效;访问互联网时,路由器把它替换成运营商分配的公网地址,这称为网络地址转换(Network Address Translation, NAT)。查看本机在局域网中的地址:
```bash
ipconfig getifaddr en0 # macOS
@@ -651,7 +651,7 @@ www.a.shifen.com. 600 IN A 183.2.172.177
```
- CNAME 表示 www.baidu.com 是 www.a.shifen.com 的别名,A 记录给出了最终的 IPv4 地址;
-- 600 是有效期(秒),在此期间可以直接使用缓存的结果;
+- 600 是有效期(秒),在此期间可以直接使用缓存的结果;从缓存返回的记录显示的是剩余的秒数,再查一次通常会看到它变小;
- SERVER 一行说明这次是由家里的路由器 192.168.1.1 回答的,耗时 5 毫秒。
### 分层
@@ -667,7 +667,7 @@ www.a.shifen.com. 600 IN A 183.2.172.177
-路由器只看 IP 首部中的目的地址,按自己的路由表决定下一站交给谁,并换上新的帧首部;它不关心里面是 HTTP 还是别的内容。只有两端的主机才会处理 TCP 和 HTTP。分层的好处在于各层可以独立变化,例如手机从 Wi-Fi 切换到 4G 只换了链路层,HTTP 请求的内容不受影响。
+路由器只看 IP 首部中的目的地址,按自己的路由表决定下一站交给谁,并换上新的帧首部;它不关心里面是 HTTP 还是别的内容。只有两端的主机才会处理 TCP 和 HTTP。分层的好处在于各层可以独立变化,例如手机从 Wi-Fi 切换到 4G 时,链路层和 IP 地址都变了,TCP 连接要重新建立,但 HTTP 请求的格式不用任何改动。
查看到服务器要经过多长时间可以用 ping,它发出一个小数据包并等待对方回复,所用的时间称为往返时间(Round-Trip Time, RTT):
@@ -688,7 +688,7 @@ ping -c 4 www.baidu.com
- 重传:发送方一段时间内没有收到确认,就重新发送这部分数据;
- 流量控制和拥塞控制:根据接收方的处理能力和网络的拥堵情况调整发送速度。
-通信之前,双方要先建立连接,交换各自的起始序号,这个过程需要 3 个报文,称为三次握手。下面是实验中一次下单请求在 TCP 连接上的主要报文(省略了响应中间的一次确认和关闭连接的报文),序号是抓包得到的真实数值(Ubuntu 24.04 实测,见[附录 A7](#a7-http-请求与-tcp-报文)):
+通信之前,双方要先建立连接,交换各自的起始序号,这个过程需要 3 个报文,称为三次握手。SYN 和 ACK 是 TCP 首部中的两个标志:SYN 表示请求建立连接并带上自己的起始序号,ACK 表示报文中的确认号有效;图中的 seq 是序号,ack 是确认号。下面是实验中一次下单请求在 TCP 连接上的主要报文(省略了响应中间的一次确认和关闭连接的报文),序号是抓包得到的真实数值(Ubuntu 24.04 实测,见[附录 A7](#a7-http-请求与-tcp-报文)):
@@ -718,7 +718,7 @@ curl -v -H 'Content-Type: application/json' \
-d '{"userId":1001,"dishId":17,"quantity":1}' http://127.0.0.1:8080/api/orders
```
-curl 发出的请求(以 > 开头)和收到的响应(以 < 开头):
+curl 发出的请求(以 > 开头)和收到的响应(以 < 开头),这里和下面的输出省略了 Date 等首部:
```text
> POST /api/orders HTTP/1.1
@@ -739,10 +739,10 @@ curl 发出的请求(以 > 开头)和收到的响应(以 < 开头):
请求由三部分组成:
- 请求行:方法 POST 表示提交数据、创建资源,路径 /api/orders 表示订单,最后是协议版本;
-- 首部:每行一个“名称: 值”,例如 Content-Type 说明请求体是 JSON 格式,Content-Length 说明请求体有 40 个字节;
+- 首部:每行一个“名称: 值”,例如 Content-Type 说明请求体是 JavaScript 对象表示法(JavaScript Object Notation, JSON),一种表示数据的文本格式,这里是花括号括起的若干“名称: 值”,Content-Length 说明请求体有 40 个字节;
- 请求体:空行之后的 {"userId":1001,"dishId":17,"quantity":1}。
-响应的第一行是状态行,201 是状态码,表示创建成功。状态码按第一位数字分类:2xx 表示成功,3xx 表示重定向,4xx 表示客户端的错误(例如查询不存在的订单返回 404 Not Found),5xx 表示服务器的错误。查询订单用 GET 方法:
+响应的第一行是状态行,201 是状态码,表示创建成功。状态码按第一位数字分类:2xx 表示成功,3xx 表示重定向(例如网页换了地址,服务器告诉客户端到新地址重新请求),4xx 表示客户端的错误(例如查询不存在的订单返回 404 Not Found),5xx 表示服务器的错误。查询订单用 GET 方法:
```bash
curl -i http://127.0.0.1:8080/api/orders/1024
@@ -767,7 +767,7 @@ HTTP 本身不保存状态,每个请求都是独立的,服务器不会记得
### HTTPS
-HTTP 是明文传输的,同一个 Wi-Fi 下的其他人或沿途的路由器都能看到、甚至修改请求内容。HTTPS 在 TCP 和 HTTP 之间加了一层 TLS(Transport Layer Security):
+HTTP 是明文传输的,同一个 Wi-Fi 下的其他人或沿途的路由器都能看到、甚至修改请求内容。HTTPS 在 TCP 和 HTTP 之间加了一层传输层安全协议(Transport Layer Security, TLS):
- 加密:双方在 TLS 握手中协商出一个只有彼此知道的密钥,之后的 HTTP 报文都加密传输;
- 认证:服务器出示由可信机构签发的证书,证明自己确实是 shop.example.com,防止连到假冒的服务器;
@@ -817,13 +817,13 @@ dns 0.002281 tcp 0.011717 tls 0.041322 first_byte 0.053568
1. IP 地址标识网络中的一台主机,相当于门牌号;端口标识主机上的一个进程,取值 0~65535,相当于房间号,例如 HTTPS 用 443;一个连接由客户端 IP、客户端端口、服务器 IP、服务器端口 4 个数共同确定,不同手机的地址或端口不同就是不同的连接,操作系统据此把数据分给对应的连接。
2. 手机先问本地 DNS 服务器(家里的路由器,它一般转给运营商的 DNS 服务器);有缓存就直接回答,没有就从根服务器开始,依次询问负责 .com、负责 example.com 的服务器,最终得到 IP 地址;结果按有效期(例如 600 秒)缓存,期间可以直接使用。
-3. 把请求送达要解决的问题很多,分层后每层只解决一类问题、使用下一层的服务,各层可以独立变化,例如手机从 Wi-Fi 切到 4G 只换了链路层;应用层规定请求和响应的内容(HTTP、DNS);传输层在两个进程之间传数据,用端口区分进程(TCP、UDP);网络层用 IP 地址把数据从一台主机送到另一台,由路由器逐跳转发;链路层在同一个网络中把数据交给下一站(以太网、Wi-Fi)。
+3. 把请求送达要解决的问题很多,分层后每层只解决一类问题、使用下一层的服务,各层可以独立变化,例如手机从 Wi-Fi 切到 4G 时链路层和 IP 地址都变了,HTTP 请求的格式不用改;应用层规定请求和响应的内容(HTTP、DNS);传输层在两个进程之间传数据,用端口区分进程(TCP、UDP);网络层用 IP 地址把数据从一台主机送到另一台,由路由器逐跳转发;链路层在同一个网络中把数据交给下一站(以太网、Wi-Fi)。
动手:执行 `dig www.baidu.com` 和 `ping -c 4 www.baidu.com`,找出解析得到的 IP 地址、记录的有效期和往返时间。
-预期:dig 的 ANSWER SECTION 中,www.baidu.com 是 www.a.shifen.com 的别名(CNAME),A 记录给出 IP 地址(笔记实测 183.2.172.177),有效期 600 秒;ping 显示往返时间,笔记在家庭宽带上实测平均约 9.7 ms,具体数字随网络和地区不同。
+预期:dig 的 ANSWER SECTION 中,www.baidu.com 是 www.a.shifen.com 的别名(CNAME),A 记录给出 IP 地址(笔记实测 183.2.172.177);有效期是一个秒数(笔记实测 600),从缓存返回时是剩余的秒数,所以各人看到的数字不同,有的路由器从缓存回答时只给出 A 记录、不显示 CNAME;ping 显示往返时间,笔记在家庭宽带上实测平均约 9.7 ms,具体数字随网络和地区不同。
明天:第 8 天,读[TCP](#tcp)、[UDP](#udp)。
@@ -846,7 +846,7 @@ dns 0.002281 tcp 0.011717 tls 0.041322 first_byte 0.053568
-动手:在一个终端中执行 sudo tcpdump -nn -S 'tcp port 80' 开始抓包(sudo 会要求输入当前用户的登录密码,-S 显示原始序号),在另一个终端中执行 `curl http://example.com`,然后回到第一个终端按 Ctrl + C 停止,找出三次握手的 3 个报文,对照[TCP](#tcp)一节中的图核对序号和确认号的关系。
+动手:在一个终端中执行 sudo tcpdump -nn -S 'tcp port 80' 开始抓包(sudo 会要求输入当前用户的登录密码,-S 显示原始序号),在另一个终端中执行 `curl http://example.com`(Ubuntu 上没有 curl 时用 sudo apt install curl 安装),然后回到第一个终端按 Ctrl + C 停止,找出三次握手的 3 个报文,对照[TCP](#tcp)一节中的图核对序号和确认号的关系。
预期:前 3 个报文依次是 SYN、SYN + ACK、ACK(tcpdump 中标为 [S]、[S.]、[.]):第 2 个报文的确认号等于第 1 个的序号加 1,第 3 个报文的确认号等于服务器的起始序号加 1;不加 -S 时 tcpdump 显示相对序号(例如 ack 1)。
@@ -873,7 +873,7 @@ dns 0.002281 tcp 0.011717 tls 0.041322 first_byte 0.053568
动手:用[把过程连起来](#把过程连起来)一节中带 -w 参数的 curl 命令访问几个常用的网站,比较 DNS、TCP、TLS 各阶段的耗时。
-预期:每个网站输出一行 dns、tcp、tls、first_byte 4 个依次增大的累计秒数,相邻两项相减得到各阶段耗时;笔记访问百度时 DNS 约 2 ms、TCP 约 9 ms、TLS 约 30 ms、首字节约 12 ms,通常 TLS 握手最慢,服务器离得越远,TCP、TLS 阶段越长。
+预期:每个网站输出一行 dns、tcp、tls、first_byte 4 个依次增大的累计秒数,相邻两项相减得到各阶段耗时;笔记访问百度时 DNS 约 2 ms、TCP 约 9 ms、TLS 约 30 ms、首字节约 12 ms。哪一段最慢因网站而异:百度协商的是 TLS 1.2,握手要两个往返,TLS 阶段约为 TCP 阶段的 3 倍;TLS 1.3 的完整握手通常只要一个往返;有的网站首字节阶段最长,因为它包含服务器生成页面的时间。服务器离得越远,TCP、TLS 阶段越长。
综合题:从点击“提交订单”到 App 显示“下单成功”:按 DNS、TCP、HTTP 的顺序,说出每一步发送了什么、发给了谁,以及哪些步骤要花一个往返时间。(见[一次下单经过了什么](#一总览一次下单经过了什么)、[TCP](#tcp)、[把过程连起来](#把过程连起来))
@@ -925,7 +925,7 @@ id user_id dish_id amount status created_at
### SQL
-结构化查询语言(Structured Query Language, SQL)是操作关系型数据库的标准语言。在终端中执行 sqlite3 -header -column shop.db 打开(不存在时新建)一个数据库文件,然后逐条输入语句。-header -column 让查询结果带列名并按列对齐,和下文的输出一样;不加时每行的各列用 | 隔开。
+结构化查询语言(Structured Query Language, SQL)是操作关系型数据库的标准语言。在终端中执行 sqlite3 -header -column shop.db 打开(不存在时新建)一个数据库文件,然后逐条输入语句。-header -column 让查询结果带列名并按列对齐,和下文的输出一样;不加时每行的各列用 | 隔开。SQLite 3.51 之前按字符数对齐,含中文的列会错开几格,内容不变。
建表时说明每一列的名称和类型:
@@ -1094,7 +1094,7 @@ SQL 的更多语法见 [SQL 语法](SQL%20语法.md#七查询);事务、ACID
自测:
1. 为什么用数据库保存订单,而不是直接写文件?(见[为什么需要数据库](#为什么需要数据库))
-2. 什么是主键?再插入一个相同主键的订单会怎样?(见[SQL](#sql))
+2. 什么是主键?再插入一个相同主键的订单会怎样?(见[表](#表)、[SQL](#sql))
参考要点
@@ -1216,7 +1216,7 @@ SQL 的更多语法见 [SQL 语法](SQL%20语法.md#七查询);事务、ACID
只要桶的数量和元素数量相当、哈希函数把键分散得足够均匀,每个桶中平均只有一两个元素。用 100 万个随机的订单号、约 100 万个桶实测,查找一个订单平均只比较 1.48 次(见[附录 A11](#a11-比较次数))。元素越来越多时,哈希表会把桶数组扩大一倍,重新分配所有元素,让链表保持很短。
-哈希表的缺点是元素没有顺序,不能回答“12 点到 12 点半之间有哪些订单”这类范围查询。Java 的 HashMap 和 Redis 保存所有键的字典都是哈希表。
+哈希表的缺点是元素没有顺序,不能回答“12 点到 12 点半之间有哪些订单”这类范围查询。Java 的 HashMap 和 Redis(一种把数据保存在内存中的数据库)保存所有键的字典都是哈希表。
### 二分查找
@@ -1260,7 +1260,7 @@ echo 'l(1000000)/l(2)' | bc -l
如果数据按顺序插入,二叉查找树会退化成一条链表,查找又变成逐个比较。实际使用的是能自动保持平衡的树,例如红黑树。
-二叉树每个节点只有两个分支,100 万个元素至少要 20 层。如果树放在磁盘上,每往下走一层就要读一次磁盘,20 次随机读取就要 1 毫秒以上。数据库的索引因此让每个节点占一个磁盘页、放几百个键,节点的分支多了,树就很矮。[索引](#索引)一节实验中的索引就是这样:根页有 10 个键,中间页平均约 270 个,叶子页平均约 350 个,100 万个条目只用了 3 层(SQLite 实测,见[附录 A9](#a9-索引))。根页也装满时,3 层可以容纳约 270 × 270 × 350 ≈ 2500 万个条目。MySQL 使用的 B+ 树是这种多路树的一种,只在叶子页中存放数据,叶子页之间用链表相连,便于范围查询。
+二叉树每个节点只有两个分支,100 万个元素至少要 20 层。如果树放在磁盘上,每往下走一层就要读一次磁盘,20 次随机读取就要 1 毫秒以上。数据库的索引因此让每个节点占一个磁盘页、放几百个键,节点的分支多了,树就很矮。[索引](#索引)一节实验中的索引就是这样:根页有 10 个键,中间页约 250~270 个,叶子页平均约 350 个,100 万个条目只用了 3 层(SQLite 实测,见[附录 A9](#a9-索引))。根页也装满时,3 层可以容纳约 270 × 270 × 350 ≈ 2500 万个条目。MySQL 使用的 B+ 树是这种多路树的一种,只在叶子页中存放数据,叶子页之间用链表相连,便于范围查询。
### 排序
@@ -1471,13 +1471,13 @@ sort 使用的是 O(n log n) 的算法,100 万个数排序只用了约 0.5 秒
自测:
-1. 二分查找的时间复杂度是多少?100 万个元素最多比较几次?(见[二分查找](#二分查找))
+1. 二分查找为什么快?100 万个元素最多比较几次?(见[二分查找](#二分查找))
2. 数据库索引为什么用 B+ 树,而不用二叉树或哈希表?(见[树](#树))
参考要点
-1. 二分查找每比较一次排除一半,时间复杂度是 O(log n);n 个元素最多比较 log₂n 向下取整再加 1 次,100 万约等于 2²⁰,最多比较 20 次;前提是数据已排好序并能按位置直接读取,所以只适用于有序数组。
+1. 二分查找每比较一次排除一半,比较次数随元素个数按对数增长(第 17 天的[时间复杂度](#时间复杂度)中记作 O(log n));n 个元素最多比较 log₂n 向下取整再加 1 次,100 万约等于 2²⁰,最多比较 20 次;前提是数据已排好序并能按位置直接读取,所以只适用于有序数组。
2. 哈希表的元素没有顺序,不能做“12:00~12:30 的订单”这类范围查询;二叉树每个节点只有两个分支,100 万个元素至少 20 层,放在磁盘上每往下一层就读一次磁盘,20 次随机读要 1 毫秒以上;B+ 树这类多路树每个节点占一个磁盘页、放几百个键,树很矮,实验中 100 万个条目只要 3 层,3 层约能容纳 2500 万个;B+ 树的数据只放在叶子页,叶子页之间用链表相连,便于范围查询。
@@ -1625,20 +1625,20 @@ Git 记录代码的每一次修改,可以回到任何一个历史版本,也
自测:
-1. Git 和 SVN 有什么区别?(见[集中式与分布式](Git.md#集中式与分布式))
+1. git merge 和 git rebase 有什么区别?(见[Git 命令一览](Git.md#git-命令一览))
2. 合并分支时出现冲突怎样解决?(见[冲突](Git.md#冲突))
3. git stash 有什么作用?(见[储藏(Stashing)](Git.md#储藏stashing))
参考要点
-1. Git 是分布式版本控制,每个人的电脑上都有完整的历史;SVN 是集中式,完整的历史只在中心服务器上,每个人只有某个版本的工作副本。SVN 不联网也能修改和撤销本地改动,但提交、查看历史要连接服务器,服务器出故障时这些操作都做不了;Git 不联网也能提交、查看历史。SVN 的分支是服务器上的廉价复制,Git 新建、合并分支只需在本地移动指针。
+1. 两个分支都有新提交时,merge 生成一个有两个父提交的合并提交,原有的提交不变,历史中保留分叉和汇合;rebase 把当前分支的提交逐个放到目标分支最新的提交之后重新提交一遍,历史成为一条直线,但这些提交的编号(哈希)都变了,所以别人已经拉取的提交不要变基。
2. 两个分支修改了同一个文件的同一行,合并时就会冲突;Git 在文件中用 <<<<<<<、=======、>>>>>>> 标出两边的内容,把这一段改成最终想要的内容,并删掉这三行标记;然后执行 git add 标记冲突已解决,再执行 git commit 完成合并。
3. git stash 把工作区中还没提交的修改存起来,工作区回到干净的状态,可以安全地切换分支;例如在 dev 上开发到一半,要去修 master 上的 bug,先执行 git stash,修完回来用 git stash pop 恢复;未跟踪的新文件默认不储藏,需要加 -u。
-动手:在终端中依次执行下面的命令,两个分支把宫保鸡丁的价格改成不同的值后合并。前两行设置提交记录中的用户名和邮箱,只需执行一次;没有 git 命令时,Ubuntu 用 sudo apt install git 安装,macOS 按弹出的提示安装命令行工具。git switch -c dev 新建并切换到 dev 分支,git switch - 回到原来的分支(默认叫 master 或 main,取决于配置)。
+动手:在终端中依次执行下面的命令,两个分支把宫保鸡丁的价格改成不同的值后合并。前两行设置提交记录中的用户名和邮箱,只需执行一次;没有 git 命令时,Ubuntu 用 sudo apt install git 安装,macOS 按弹出的提示安装命令行工具。git init 把当前目录变成 Git 仓库(它输出的关于默认分支名的提示可以忽略),echo 加 > 用引号中的一行文字覆盖 menu.txt 的内容,&& 表示前一条命令成功后才执行后一条;git switch -c dev 新建并切换到 dev 分支,git switch - 回到原来的分支(默认叫 master 或 main,取决于配置)。
```bash
git config --global user.name "你的名字"
@@ -1653,7 +1653,7 @@ echo "宫保鸡丁 3000" > menu.txt && git commit -am "price 3000"
git merge dev
```
-预期:git merge 提示 CONFLICT (content): Merge conflict in menu.txt,menu.txt 变成 <<<<<<< HEAD、宫保鸡丁 3000、=======、宫保鸡丁 2600、>>>>>>> dev 五行;把文件改成想保留的一行(例如宫保鸡丁 2600),执行 git add menu.txt 和 git commit -m "merge dev" 完成合并;git log --oneline --graph 中两条分支线(|\ 和 |/)汇合到这个合并提交。
+预期:git merge 提示 CONFLICT (content): Merge conflict in menu.txt,menu.txt 变成 <<<<<<< HEAD、宫保鸡丁 3000、=======、宫保鸡丁 2600、>>>>>>> dev 五行;把文件改成想保留的一行(例如执行 echo "宫保鸡丁 2600" > menu.txt),执行 git add menu.txt 和 git commit -m "merge dev" 完成合并;git log --oneline --graph 中两条分支线(|\ 和 |/)汇合到这个合并提交。
明天:第 19 天,复习全篇。
@@ -1842,7 +1842,7 @@ write(2, ...) 是服务程序在标准错误上打印访问日志,正文的图
$ strace -e trace=write echo "order 1024"
write(1, "order 1024\n", 11order 1024
) = 11
-$ strace -c cat /etc/hostname | tail -1
+$ strace -c cat /etc/hostname 2>&1 >/dev/null | tail -1
100.00 0.000874 21 41 1 total
```
@@ -1875,7 +1875,7 @@ curl -v 显示这次连接使用 TLS 1.2,服务器在 ALPN 中选择了 http/1
### A7 HTTP 请求与 TCP 报文
-模拟的订单服务用 Python 标准库编写,每个请求由一个新线程处理:POST /api/orders 向 orders.log 追加一行并返回 201,GET /api/orders/1024 返回订单,其它路径返回 404。
+模拟的订单服务用 Python 标准库编写,每个连接由一个新线程处理(下面每次 curl 只在一个连接上发一个请求):POST /api/orders 向 orders.log 追加一行并返回 201,GET /api/orders/1024 返回订单,其它路径返回 404。
```python
import json, time
@@ -1997,7 +1997,7 @@ Run Time: real 0.000 user 0.000008 sys 0.000006
pagetype pages cells avg_cells
internal 12 2852 237.7
leaf 2853 997148 349.5
-根页 / 的条目数 10,中间页 /000/、/001/ 的条目数各 271
+根页 / 的条目数 10,11 个中间页的条目数为 245~271(/000/~/002/ 各 271)
```
用户 1001 的订单号为 79000、179000……979000。