技术笔记 on Revival-of-hope

算法笔记

Sat, 25 Apr 2026 09:55:45 +0800

数据结构

栈

队列

哈希表

基础算法

复杂度分析

二分大法

二分法本身的思想不难,最难的是写<=还是<的时候. 事实上,二分法总共只有两种写法,一个是左闭右闭,一个是左闭右开,但如果两种方法混着用,很容易就记混了,现场推导或许也可以,但总归是要想一下子的. 故我认为只使用下面一种逻辑算法就行了,因为两端均为闭区间最符合正常人直觉.

1
2
3
4
5
6
7
8


 while (l <= r) {
 int mid = (l + r) / 2;
 res = findsum(mid);
 if (res >= k)
 l = mid + 1;
 else
 r = mid - 1;
 }

排序

冒泡排序

搜索

事实上,翻遍全网,找不到一个真正详尽的入门教程,基本都是丢给你几道算法题的解答就结束了,却从来没有真正的讲明白为什么要这样写

到底是用dfs还是bfs?(3/14)

参考文章问ai或者上网查,很容易就知道bfs用来求最短路径,而dfs用来求路径条数,那么,为什么是这样呢? 先概览一下代码: dfs

 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


#include <bits/stdc++.h>
using namespace std;

const int MAX = 105;

int n,m;
char g[MAX][MAX];
int vis[MAX][MAX];

int dx[4]={-1,1,0,0};
int dy[4]={0,0,-1,1};

void dfs(int x,int y)
{
 vis[x][y]=1;

 for(int i=0;i<4;i++)
 {
 int nx=x+dx[i];
 int ny=y+dy[i];

 if(nx<1||nx>n||ny<1||ny>m)
 continue;

 if(vis[nx][ny])
 continue;

 if(g[nx][ny]=='#')
 continue;

 dfs(nx,ny);
 }
}

int main()
{
 int sx,sy;

 cin>>n>>m;

 for(int i=1;i<=n;i++)
 for(int j=1;j<=m;j++)
 {
 cin>>g[i][j];
 if(g[i][j]=='S')
 sx=i,sy=j;
 }

 dfs(sx,sy);
}

可以看到dfs使用的是层层递归的方式,会一条路走到底,直到没有路可走或者找到答案才返回上一级,处理完后再返回上一级. 换句话说也就是先进后出,后来新出现的路径优先处理,这也是栈的工作原理. 所以,dfs的数据结构注定了它不能处理太大深度的复杂搜索,否则栈就很容易溢出. 比如下面这题:

1
2
3
4
5
6
7


乔治有一些同样长的小木棍，他把这些木棍随意砍成几段，直到每段的长都不超过 50。

现在，他想把小木棍拼接成原来的样子，但是却忘记了自己开始时有多少根木棍和它们的长度。

给出每段小木棍的长度，编程帮他找出原始木棍的最小可能长度。

对于全部测试点，1≤n≤65，1≤a[i]≤50

bfs

 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


#include <bits/stdc++.h>
using namespace std;

const int MAX = 105;

int n,m;
char g[MAX][MAX];
int vis[MAX][MAX];

int dx[4]={-1,1,0,0};
int dy[4]={0,0,-1,1};

struct Node{
 int x;
 int y;
 int step;
};

int bfs(int sx,int sy)
{
 queue<Node> q;

 q.push({sx,sy,0});
 vis[sx][sy]=1;

 while(!q.empty())
 {
 Node cur=q.front();
 q.pop();

 int x=cur.x;
 int y=cur.y;
 int step=cur.step;

 if(g[x][y]=='E') //终点
 return step;

 for(int i=0;i<4;i++)
 {
 int nx=x+dx[i];
 int ny=y+dy[i];

 if(nx<1||nx>n||ny<1||ny>m)
 continue;

 if(vis[nx][ny])
 continue;

 if(g[nx][ny]=='#') //墙
 continue;

 vis[nx][ny]=1;
 q.push({nx,ny,step+1});
 }
 }

 return -1;
}

int main()
{
 int sx,sy;

 cin>>n>>m;

 for(int i=1;i<=n;i++)
 for(int j=1;j<=m;j++)
 {
 cin>>g[i][j];
 if(g[i][j]=='S')
 sx=i,sy=j;
 }

 cout<<bfs(sx,sy);
}

最值得关注的便是bfs使用的是队列来存储要处理的节点,而队列的特点便是先进先出,如果遍历四个方向,那么bfs会依次处理这四个方向之后,再处理下一层的节点,这样依次扩展,直到找到终点. 那么bfs之所以能够找到最短路的原因就很明显了,如果当前层找不到终点,说明终点在下一层,如果找到了终点,说明当前路径就是最好的结果,不用继续找了.

事实上,下面才是更为常见的写法,由于OI选手一般能不写函数就不写,所以刚入门时看到这样的代码是比较难理解bfs的.

 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


#include <bits/stdc++.h>
using namespace std;

int main()
{
 const int MAX=105;

 int n,m;
 char g[MAX][MAX];
 int vis[MAX][MAX]={0};

 int dx[4]={-1,1,0,0};
 int dy[4]={0,0,-1,1};

 cin>>n>>m;

 int sx,sy;

 for(int i=1;i<=n;i++)
 for(int j=1;j<=m;j++)
 {
 cin>>g[i][j];
 if(g[i][j]=='S')
 sx=i,sy=j;
 }

 struct Node{
 int x,y,step;
 };

 queue<Node> q;

 q.push({sx,sy,0});
 vis[sx][sy]=1;

 while(!q.empty())
 {
 Node cur=q.front();
 q.pop();

 int x=cur.x;
 int y=cur.y;
 int step=cur.step;

 if(g[x][y]=='E')
 {
 cout<<step;
 break;
 }

 for(int i=0;i<4;i++)
 {
 int nx=x+dx[i];
 int ny=y+dy[i];

 if(nx<1||nx>n||ny<1||ny>m)
 continue;

 if(vis[nx][ny])
 continue;

 if(g[nx][ny]=='#')
 continue;

 vis[nx][ny]=1;
 q.push({nx,ny,step+1});
 }
 }
}

为什么要写vis数组来标记访问路径?

{% raw %}

<style>
 /* 针对 Butterfly 的局部隔离样式 */
 #dfs-root button { 
 cursor: pointer; padding: 6px 14px; border-radius: 6px; font-size: 13px; font-weight: 600; 
 margin: 4px; border: 1px solid #e2e8f0; transition: all 0.2s; background: #fff; color: #475569;
 }
 #dfs-root button:hover { border-color: #3b82f6; color: #3b82f6; }
 #dfs-root .active-btn { background: #3b82f6 !important; color: #fff !important; border-color: #2563eb !important; }
 
 #dfs-root .grid-container { 
 display: grid; grid-template-columns: repeat(3, minmax(50px, 70px)); gap: 8px; 
 background-color: #f1f5f9; padding: 10px; border-radius: 8px; width: fit-content; margin: 20px auto;
 }
 #dfs-root .cell { 
 aspect-ratio: 1/1; display: flex; align-items: center; justify-content: center; 
 font-size: 14px; font-weight: bold; border-radius: 4px; border: 1px solid #e2e8f0;
 background: #fff; transition: background 0.1s; 
 }
 #dfs-root .v { background-color: #cbd5e1; color: #64748b; } /* visited */
 #dfs-root .c { background-color: #3b82f6; color: #fff; transform: scale(0.95); } /* current */
 #dfs-root .s { outline: 3px solid #22c55e; outline-offset: -2px; } /* start */
 #dfs-root .e { outline: 3px solid #ef4444; outline-offset: -2px; } /* end */
 
 #dfs-root .console { 
 background: #f8fafc; padding: 12px; border-radius: 6px; font-family: 'Fira Code', monospace;
 font-size: 13px; border-left: 4px solid #3b82f6; min-height: 50px;
 }
</style>

<div style="display: flex; flex-wrap: wrap; justify-content: center; margin-bottom: 10px;">
 <button onclick="dfsApp.run('no_mark', this)">1. 无标记 (死循环)</button>
 <button onclick="dfsApp.run('no_unmark', this)">2. 无释放 (遗漏)</button>
 <button onclick="dfsApp.run('correct', this)">3. 标准回溯 (全空间)</button>
</div>

<div class="grid-container" id="dfs-grid"></div>

<div style="display: flex; justify-content: center; gap: 10px; margin-bottom: 15px;">
 <button id="dfs-pause" onclick="dfsApp.togglePause()">暂停</button>
 <button id="dfs-speed" onclick="dfsApp.toggleSpeed()">速度: 常速</button>
</div>

<div class="console">
 <div id="dfs-log">系统状态：准备就绪</div>
</div>

{% endraw %}

1
2
3
4
5
6


if (nx >= 1 && nx <= n && ny >= 1 && ny <= m && a[nx][ny] != -1 &&
 !vis[nx][ny]) {
 vis[nx][ny] = 1; // 【标记】占领这个点
 dfs(nx, ny); // 【递归】继续深入
 vis[nx][ny] = 0; // 【回溯】释放这个点，让别的路径也能经过它
 }

以此代码为例,如果不写vis[nx][ny] = 1;,则会导致搜索时反复回到已经走过的路径,造成死循环;如果不在递归后写vis[nx][ny] = 0;,会导致一个已经遍历过的路径中的方格无法被其他其他路径使用.

再解释一下为什么不写vis就会死循环:
- 从方格1到方格2后,方格2会遍历上下左右四个方向,因为方格1对于2来说是可达的,因此会回到方格1,以此往复. 因此,如果题目要求找到所有路径,或者所写算法中有往回走的可能,就需要使用vis数组,无论是dfs还是bfs.

图论

工具笔记

Wed, 08 Apr 2026 08:00:00 +0000

终端工具

本文主要聚焦于Windows系统,尽管有不少命令是和Linux通用的

网络连接

ping

系统自带组件,基于ICMP实现的网络状态查询工具,换句话说,ping借助TCP/IP协议实现对网络状态的简单解析

 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


用法: ping [-t] [-a] [-n count] [-l size] [-f] [-i TTL] [-v TOS]
 [-r count] [-s count] [[-j host-list] | [-k host-list]]
 [-w timeout] [-R] [-S srcaddr] [-c compartment] [-p]
 [-4] [-6] target_name

选项:
 -t Ping 指定的主机，直到停止。
 若要查看统计信息并继续操作，请键入 Ctrl+Break；
 若要停止，请键入 Ctrl+C。
 -a 将地址解析为主机名。
 -n count 要发送的回显请求数。
 -l size 发送缓冲区大小。
 -f 在数据包中设置“不分段”标记(仅适用于 IPv4)。
 -i TTL 生存时间。
 -v TOS 服务类型(仅适用于 IPv4。该设置已被弃用，
 对 IP 标头中的服务类型字段没有任何
 影响)。
 -r count 记录计数跃点的路由(仅适用于 IPv4)。
 -s count 计数跃点的时间戳(仅适用于 IPv4)。
 -j host-list 与主机列表一起使用的松散源路由(仅适用于 IPv4)。
 -k host-list 与主机列表一起使用的严格源路由(仅适用于 IPv4)。
 -w timeout 等待每次回复的超时时间(毫秒)。
 -R 同样使用路由标头测试反向路由(仅适用于 IPv6)。
 根据 RFC 5095，已弃用此路由标头。
 如果使用此标头，某些系统可能丢弃
 回显请求。
 -S srcaddr 要使用的源地址。
 -c compartment 路由隔离舱标识符。
 -p Ping Hyper-V 网络虚拟化提供程序地址。
 -4 强制使用 IPv4。
 -6 强制使用 IPv6。

用例

1
2


ping google.com
# 判断VPN是否有效的最快方法

curl

wiki curl,意为"Client for URLs",是ping的上位替代,可以对指定网页采用多种方式进行查询,支持几乎所有的主流通信协议.由于是开源项目,几乎所有的操作系统都会预先安装.

常用参数一览

curl 常用参数速查表

参数	全称	功能描述	典型示例
`-I`	`--head`	仅获取响应头。常用于检查服务器状态、文件大小或链接有效性。	`curl -I https://google.com`
`-v`	`--verbose`	调试模式。显示详细的通信过程，包括请求头、响应头及 TLS 握手。	`curl -v https://google.com`
`-X`	`--request`	指定请求方法。默认为 GET，可手动指定 POST, PUT, DELETE 等。	`curl -X POST https://api.com`
`-d`	`--data`	发送数据。用于 POST 请求向服务器提交表单数据或 JSON。	`curl -d "id=1" https://api.com`
`-H`	`--header`	设置请求头。常用于定义 Content-Type 或传入 API Token。	`curl -H "Auth: 123" https://api.com`
`-L`	`--location`	跟随重定向。当页面发生 301/302 跳转时，自动追踪到目标页。	`curl -L http://google.com`
`-o`	`--output`	保存为文件。将下载内容写入指定路径，而非直接打印在终端。	`curl -o test.html https://abc.com`
`-O`	`--remote-name`	远程同名保存。使用 URL 中的文件名作为本地文件名保存。	`curl -O https://abc.com/v1.zip`
`-u`	`--user`	身份认证。用于输入服务器的用户名和密码（Basic Auth）。	`curl -u user:pass https://api.com`
`-k`	`--insecure`	忽略 SSL 校验。访问证书过期或自签名的 HTTPS 站点时使用。	`curl -k https://expired-site.com`
`-s`	`--silent`	静默模式。不显示进度条或错误信息，常用于脚本自动化。	`curl -s https://api.com`
`--json`	`--json`	发送 JSON（新版本）。自动设置 Content-Type 并以 POST 方式发送。	`curl --json '{"id":1}' https://api.com`

用例

1
2
3
4
5
6
7


curl google.com
# 不带任何参数的curl也能返回足够多的信息
StatusCode : 200
StatusDescription : OK
Content : (网页内容)
ParsedHtml : mshtml.HTMLDocumentClass
RawContentLength : 80569

route

wiki 用于查看和修改本电脑的IP路由表, 一般用不上

ipconfig

wiki

微软官网介绍 Displays all current TCP/IP network configuration values and refreshes Dynamic Host Configuration Protocol (DHCP) and Domain Name System (DNS) settings. Used without parameters, ipconfig displays Internet Protocol version 4 (IPv4) and IPv6 addresses, subnet mask, and default gateway for all adapters.

即ipconfig用于查看自己电脑的TCP/IP网络配置

nslookup

wiki nslookup(Name System Lookup)用于查询DNS记录,检查DNS服务器是否正常

ssh

wiki SSH(Secure Shell)协议是一种加密网络协议，用于在不安全的网络上安全地运行网络服务.通常用于登录远程计算机的shell或命令行界面(CLI)，并在远程服务器上执行命令.

基础操作

1
2
3


ssh root@100.80.251.1
# 输入密码
# 在远程服务器中进行操作

进阶操作(待补充)

wget

wiki

GNU Wget (or just Wget, formerly Geturl, also written as its package name, wget) is a computer program that retrieves content from web servers. It is part of the GNU Project. Its name derives from “World Wide Web” and “get”, a HTTP request method. It supports downloading via HTTP, HTTPS, and FTP.

如上文所说,wget是一个用来下载网络资源的工具,尽管最初在Linux中使用,但Windows Powershell会通过管道运算符复现对应的功能.

大多数场景下curl可以直接代替wget,因此wget的出现频率正不断下降

使用示例

 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


PS C:\Users\user> wget www.baidu.com

StatusCode : 200
StatusDescription : OK
Content : <!DOCTYPE html><!--STATUS OK--><html><head><meta http-equiv="Content-Type" content="text/html;chars
 et=utf-8"><meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"><meta content="origin-when-
 cr...
RawContent : HTTP/1.1 200 OK
 Bdpagetype: 1
 Bdqid: 0x926a898e00009a46
 Connection: keep-alive
 Content-Length: 632441
 Content-Type: text/html; charset=utf-8
 Date: Wed, 08 Apr 2026 10:24:26 GMT
 P3P: CP=" OTI DS...
Forms : {form}
Headers : {[Bdpagetype, 1], [Bdqid, 0x926a898e00009a46], [Connection, keep-alive], [Content-Length, 632441]..
 .}
Images : {@{innerHTML=; innerText=; outerHTML=<img src="https://pss.bdstatic.com/static/superman/img/topnav/
 newfanyi-da0cea8f7e.png">; outerText=; tagName=IMG; src=https://pss.bdstatic.com/static/superman/im
 g/topnav/newfanyi-da0cea8f7e.png}, @{innerHTML=; innerText=; outerHTML=<img src="https://pss.bdstat
 ic.com/static/superman/img/topnav/newxueshuicon-a5314d5c83.png">; outerText=; tagName=IMG; src=http
 s://pss.bdstatic.com/static/superman/img/topnav/newxueshuicon-a5314d5c83.png}, @{innerHTML=; innerT
 ext=; outerHTML=<img src="https://pss.bdstatic.com/static/superman/img/topnav/newbaike-889054f349.p
 ng">; outerText=; tagName=IMG; src=https://pss.bdstatic.com/static/superman/img/topnav/newbaike-889
 054f349.png}, @{innerHTML=; innerText=; outerHTML=<img src="https://pss.bdstatic.com/static/superma
 n/img/topnav/newzhidao-da1cf444b0.png">; outerText=; tagName=IMG; src=https://pss.bdstatic.com/stat
 ic/superman/img/topnav/newzhidao-da1cf444b0.png}...}
InputFields : {@{innerHTML=; innerText=; outerHTML=<input name="ie" type="hidden" value="utf-8">; outerText=; tag
 Name=INPUT; name=ie; type=hidden; value=utf-8}, @{innerHTML=; innerText=; outerHTML=<input name="f"
 type="hidden" value="8">; outerText=; tagName=INPUT; name=f; type=hidden; value=8}, @{innerHTML=;
 innerText=; outerHTML=<input name="rsv_bp" type="hidden" value="1">; outerText=; tagName=INPUT; nam
 e=rsv_bp; type=hidden; value=1}, @{innerHTML=; innerText=; outerHTML=<input name="rsv_idx" type="hi
 dden" value="1">; outerText=; tagName=INPUT; name=rsv_idx; type=hidden; value=1}...}
Links : {@{innerHTML=百度首页; innerText=百度首页; outerHTML=<a class="toindex" href="/">百度首页</a>; oute
 rText=百度首页; tagName=A; class=toindex; href=/}, @{innerHTML=设置<i class="c-icon c-icon-triangle
 -down"></i>; innerText=设置; outerHTML=<a name="tj_settingicon" class="pf" href="javascript:;">设置
 <i class="c-icon c-icon-triangle-down"></i></a>; outerText=设置; tagName=A; name=tj_settingicon; cl
 ass=pf; href=javascript:;}, @{innerHTML=登录; innerText=登录; outerHTML=<a name="tj_login" class="l
 b" onclick="return false;" href="https://passport.baidu.com/v2/?login&amp;tpl=mn&amp;u=http%3A%2F%2
 Fwww.baidu.com%2F&amp;sms=5">登录</a>; outerText=登录; tagName=A; name=tj_login; class=lb; onclick=
 return false;; href=https://passport.baidu.com/v2/?login&amp;tpl=mn&amp;u=http%3A%2F%2Fwww.baidu.co
 m%2F&amp;sms=5}, @{innerHTML=

 新闻

 ; innerText= 新闻 ; outerHTML=<a class="mnav c-font-normal c-color-t" href="htt
 p://news.baidu.com" target="_blank">

 新闻

 </a>; outerText= 新闻 ; tagName=A; class=mnav c-font-normal c-color-t; href=htt
 p://news.baidu.com; target=_blank}...}
ParsedHtml : mshtml.HTMLDocumentClass
RawContentLength : 632441

从返回内容也能看出来基础功能与curl没什么区别

包管理器

Scoop(推荐)

官网

官网的介绍很简单,只有一行:

A command-line installer for Windows

由于微软自己开发了Winget包管理器,故不会预先安装Scoop,需要我们用脚本激活:

1
2


Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression

在终端输入scoop即可查询使用方式:

 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


PS C:\Users\user> scoop
Usage: scoop <command> [<args>]

Available commands are listed below.

Type 'scoop help <command>' to get more help for a specific command.

Command Summary
------- -------
alias Manage scoop aliases
bucket Manage Scoop buckets
cache Show or clear the download cache
cat Show content of specified manifest.
checkup Check for potential problems
cleanup Cleanup apps by removing old versions
config Get or set configuration values
create Create a custom app manifest
depends List dependencies for an app, in the order they'll be installed
download Download apps in the cache folder and verify hashes
export Exports installed apps, buckets (and optionally configs) in JSON format
help Show help for a command
hold Hold an app to disable updates
home Opens the app homepage
import Imports apps, buckets and configs from a Scoopfile in JSON format
info Display information about an app
install Install apps
list List installed apps
prefix Returns the path to the specified app
reset Reset an app to resolve conflicts
search Search available apps
shim Manipulate Scoop shims
status Show status and check for new app versions
unhold Unhold an app to enable updates
uninstall Uninstall an app
update Update apps, or Scoop itself
virustotal Look for app's hash or url on virustotal.com
which Locate a shim/executable (similar to 'which' on Linux)

scoop解决了应用安装路径不统一的问题,将安装的应用一律放到scoop文件夹中,而且用户可以自己指定默认安装位置.

尽管大多数应用都可以很方便的使用scoop找到,但对于已经习惯了普通安装方式的我来说还是用的不太顺手.

Winget(不推荐)

官方说明 WinGet 是一种命令行工具，使用户能够在 Windows 10、Windows 11 和 Windows Server 2025 计算机上发现、安装、升级、删除和配置应用程序

具体用法只需要在终端输入winget即可了解:

 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


PS C:\Users\user> winget

WinGet 命令行实用工具可从命令行安装应用程序和其他程序包。

使用情况: winget [<命令>] [<选项>]

下列命令有效:
 install 安装给定的程序包
 show 显示包的相关信息
 source 管理程序包的来源
 search 查找并显示程序包的基本信息
 list 显示已安装的程序包
 upgrade 显示并执行可用升级
 uninstall 卸载给定的程序包
 hash 哈希安装程序的帮助程序
 validate 验证清单文件
 settings 打开设置或设置管理员设置
 features 显示实验性功能的状态
 export 导出已安装程序包的列表
 import 安装文件中的所有程序包
 pin 管理包钉
 configure 将系统配置为所需状态
 download 从给定的程序包下载安装程序
 repair 修复所选包
 dscv3 DSC v3 资源命令
 mcp MCP 信息

要搜索某个工具，请键入 winget search
确认你需要的工具可用后，可以通过键入来winget install 该工具。 WinGet 工具会启动安装程序，将应用程序安装在你的电脑上

使用举例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


PS C:\Users\uesr> winget search npm
名称 ID 版本 匹配 源
---------------------------------------------------------------------
Node.js OpenJS.NodeJS 25.9.0 Command: npm winget
Node.js 10 OpenJS.NodeJS.… 10.24.1 Command: npm winget
Node.js 12 OpenJS.NodeJS.… 12.22.12 Command: npm winget
Node.js 14 OpenJS.NodeJS.… 14.21.3 Command: npm winget
# 一大堆类似的包

PS C:\Users\user> winget install bun
找到多个与输入条件匹配的程序包。请修改输入。
名称 ID 源
-------------------------------------
Bundle Generator 9NBLGGH43PMQ msstore
Bun Oven-sh.Bun winget
# 由于我这里已经安装了,所以就会报错

winget默认全局安装,如果不操心应用安装位置的话,使用winget比上官网找资源是要快一点的;但捣鼓计算机的一般都很在意应用的安装位置,所以winget基本就没什么用了…

–version

尽管很多工具都支持工具名 –version的方式查询版本,但遗憾的是有一些工具不愿意沿用这个惯例,所以只好单独在这里分类讨论了

事实上,尽管大多数工具都统一使用–参数的形式,但也有不少工具使用-参数的形式,真的就没人想过统一一下吗…

构建工具

gcc/g++
make
tar
git
cmake
git
docker
curl

编程

python
node
npm
ruby
java: 使用java -version也可以

不支持的

go: go version,何必少写那两横呢

技术文章阅读笔记合集

Tue, 31 Mar 2026 08:00:00 +0000

重构改善既有代码的设计

ch1: Intro

如果你要给程序添加一个特性，但发现代码因缺乏良好的结构而不易于进行更改，那就先重构那个程序，使其比较容易添加该特性，然后再添加该特性。

无论每次重构多么简单，养成重构后即运行测试的习惯非常重要。犯错误是很容易的——至少我知道我是很容易犯错的。做完一次修改就运行测试，这样在我真的犯了错时，只需要考虑一个很小的改动范围，这使得查错与修复问题易如反掌。这就是重构过程的精髓所在：小步修改，每次修改后就运行测试。如果我改动了太多东西，犯错时就可能陷入麻烦的调试，并为此耗费大把时间。小步修改，以及它带来的频繁反馈，正是防止混乱的关键。

这章用了巨量的篇幅来修改一个几十行的js代码,从而说明了一个良好的早期架构是有多么的重要,一旦那些架构混乱的项目开始变得复杂,就算是神仙来了也未必能够轻易看懂并重构

关键点: 尽可能多的使用OOP,通过多态,继承,接口来实现代码复用和类型统一;通过将复杂表达式拆分为工具函数并择合适的名字来增强代码的可读性

ch2: 重构的原则

重构有两种词性,一种是动词,一种是名词:

重构（名词）：对软件内部结构的一种调整，目的是在不改变软件可观察行为的前提下，提高其可理解性，降低其修改成本。
重构（动词）：使用一系列重构手法，在不改变软件可观察行为的前提下，调整其结构。

如果我看见一块凌乱的代码，但并不需要修改它，那么我就不需要重构它。如果丑陋的代码能被隐藏在一个 API 之下，我就可以容忍它继续保持丑陋。只有当我需要理解其工作原理时，对其进行重构才有价值。另一种情况是，如果重写比重构还容易，就别重构了。这是个困难的决定。如果不花一点儿时间尝试，往往很难真实了解重构一块代码的难度。决定到底应该重构还是重写，需要良好的判断力与丰富的经验，我无法给出一条简单的建议。

如果一支团队想要重构，那么每个团队成员都需要掌握重构技能，能在需要时开展重构，而不会干扰其他人的工作。这也是我鼓励持续集成的原因：有了 CI，每个成员的重构都能快速分享给其他同事，不会发生这边在调用一个接口那边却已把这个接口删掉的情况；如果一次重构会影响别人的工作，我们很快就会知道。自测试的代码也是持续集成的关键环节，所以这三大实践——自测试代码、持续集成、重构——彼此之间有着很强的协同效应。

ch3: 代码的坏味道

需要重构的特征有以下几个:

难以捉摸的命名
重复的代码段
函数太长: 将值得用注释说明的部分拆分成函数
过长参数列表: 使用类来传入参数
全局数据: 用函数或者类来封装这个全局数据,尽量控制其作用域
可变数据: 如果一个数据有不同的用途,最好将它按照用途分成不同的类
模块边界不清晰
修改一次需要在多个地方更改

ch4: 构筑测试体系

确保所有测试都完全自动化，让它们检查自己的测试结果。

频繁地运行测试。对于你正在处理的代码，与其对应的测试至少每隔几分钟就要运行一次，每天至少运行一次所有的测试。

考虑可能出错的边界条件，把测试火力集中在那儿。

每当你收到 bug 报告，请先写一个单元测试来暴露这个 bug。

ch6: 第一组

提炼函数(Extract Function)

用例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


function printOwing(invoice) {
 printBanner();
 let outstanding = calculateOutstanding();

 //print details
 console.log(`name: ${invoice.customer}`);
 console.log(`amount: ${outstanding}`);
}

function printOwing(invoice) {
 printBanner();
 let outstanding = calculateOutstanding();
 printDetails(outstanding);

 function printDetails(outstanding) {
 console.log(`name: ${invoice.customer}`);
 console.log(`amount: ${outstanding}`);
 }
}

对于“何时应该把代码放进独立的函数”这个问题，我曾经听过多种不同的意见。有的观点从代码的长度考虑，认为一个函数应该能在一屏中显示。有的观点从复用的角度考虑，认为只要被用过不止一次的代码，就应该单独放进一个函数；只用过一次的代码则保持内联（inline）的状态。但我认为最合理的观点是“将意图与实现分开”：如果你需要花时间浏览一段代码才能弄清它到底在干什么，那么就应该将其提炼到一个函数中，并根据它所做的事为其命名。以后再读到这段代码时，你一眼就能看到函数的用途，大多数时候根本不需要关心函数如何达成其用途（这是函数体内干的事）。

如果想要提炼的代码非常简单，例如只是一个函数调用，只要新函数的名称能够以更好的方式昭示代码意图，我还是会提炼它；但如果想不出一个更有意义的名称，这就是一个信号，可能我不应该提炼这块代码。不过，我不一定非得马上想出最好的名字，有时在提炼的过程中好的名字才会出现。有时我会提炼一个函数，尝试使用它，然后发现不太合适，再把它内联回去，这完全没问题。只要在这个过程中学到了东西，我的时间就没有白费。

“如果需要返回的变量不止一个，又该怎么办呢？”

有几种选择。最好的选择通常是：挑选另一块代码来提炼。我比较喜欢让每个函数都只返回一个值，所以我会安排多个函数，用以返回多个值。如果真的有必要提炼一个函数并返回多个值，可以构造并返回一个记录对象—不过通常更好的办法还是回过头来重新处理局部变量

内联函数（Inline Function）

这里的内联指的是将不必要的中间层删除,从而让函数更加清晰

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


function getRating(driver) {
 return moreThanFiveLateDeliveries(driver) ? 2 : 1;
}

function moreThanFiveLateDeliveries(driver) {
 return driver.numberOfLateDeliveries &gt; 5;
}


function getRating(driver) {
 return (driver.numberOfLateDeliveries &gt; 5) ? 2 : 1;
}

这显然与前面说的提炼函数正好相反,从而说明重构并不是一个简单的活儿,你不好判断加入函数和删除函数这两种做法哪一种会让代码更清晰

break&总结

后面的部分都是一些具体用例了,大部分内容都需要真正去实践才能体会,所以就不建议去看了.

提炼一下本书的精华:

软件的初步架构需要是合理的,工程化的,否则后期的重构难度甚至超过推翻重写
重构一般是一次一小步进行的,如果你的重构会让项目暂时无法运行,说明你做的不是重构
重构的方法有以下几种:
1. 提炼/删除函数
2. 用类来存放函数和变量
3. 去除不必要的全局变量
4. 改一个好的名字
重构与添加新功能可以是同时进行的

程序员自我修养

讲的很深,可惜的是逻辑比较混乱,如果能再版后重构一下就真的是神书了 GitHub下载链接

OUTLINE

简介
编译和链接
目标文件里有什么
静态链接
windows PE/COFF
exe的装载与进程
动态链接
Linux的共享库
Windows中的动态链接
内存
运行库
系统调用与API
运行库的实现

可以很明显的看出来,这本书主要涉及的是C语言程序经过编译与链接后装载的过程.

编译和链接

程序运行的过程

当我们使用GCC编译Hello World程序时,只需要这样写:

1
2


gcc hello.c -o ./a.out
# './a.out'是文件名和路径,后缀名可以随便起,写成tho没有后缀或者a.xyz也可以

上述过程可以分解为4个步骤:

预处理(Preprocessing)
编译(Compilation)
汇编(Assembly)
链接(Linking)

预处理

c文件和h文件会被预处理成.i文件,cpp文件和hpp文件会被预处理为.ii文件.

对应的命令为gcc -E hello.c -o a.i 该阶段主要处理源代码中以"#“打头的预编译指令,如’#include’,’#define’等,主要运行过程如下:

将所有的”#define"删除,并展开所有的宏定义,比如,将含有"#define PI 3.14"的文件中的所有PI替换为3.14
处理所有的条件预编译指令,如"#if",“endif"等
处理”#include",将被包含的文件插入到文件中该预编译指令所在的行,该过程是递归执行的
删除所有的注释"//“和”/* */"
添加行号和文件名标识,如 " #2 “hello.c” 2 “,这就是我们在程序报错的时候看到的那些行号和文件名的来历,至于行尾的2,是一个给编译器看的标志位
保留所有的”#pragma"指令

因此,经过预处理后的.i文件不包含任何宏定义,包含的文件也被插入到.i文件中

编译

对.i文件进行一系列词法分析,语法分析,语义分析和优化,生成相应的汇编代码文件.

对应的命令为gcc -S hello.i -o hello.s

汇编

根据汇编代码构建目标文件

对应的命令为gcc -c hello.s -o hello.o
- 或者一步完成: gcc -c hello.c -o hello.o

链接

1

ld -static crt1.o crti.o crtbeginT.o hello.o -start-group -1gcc -1gcc_eh -1c -end-group crtend.o crtn.o

可以看到需要链接一堆文件才可以得到最终的可执行文件

编译的详细原理

下面我们来以一段简单的c语言代码为例来分析编译的全过程:

1

array[index] = (index+4)*(2+ 6)

词法分析

源代码被输入到扫描器(Scanner),产生一系列记号:关键字,标识符,数字,字符串和特殊符号(加号,等号)等.

语法分析

语法分析器(Grammar Parser)对扫描器产生的记号进行语法分析,产生由表达式组成的语法树(Syntax Tree)

语义分析

语义分析器(Semantic Analyzer)对表达式进行静态的语义分析,标识各个表达式的类型;动态语义则只能在运行期确定.

中间代码的生成

现代编译器会对源代码进行优化,将整个语法树转换成中间代码,尽管非常接近目标代码,但它与运行的操作系统无关,不包含数据尺寸,变量地址和寄存器名字等信息. 根据中间代码可以把编译器分为前端和后端.前端负责产生于操作系统无关的中间代码,后端负责将中间代码转换成目标文件 Java 编译体系 (Bytecode)

前端：javac。它将 .java 源码编译成与平台无关的 Java Bytecode (.class 文件)。这就是所谓的中间代码。

后端：JVM (Java Virtual Machine) 中的 JIT 编译器 (如 C1、C2)。当程序运行时，JIT 将字节码转换为当前运行机器（Windows x64、Linux ARM 等）的具体指令集。

目标代码的生成与优化

编译器后端主要包括代码生成器和目标代码优化器二者. 代码生成器将中间代码转换成目标机器代码,例如:

1
2
3
4
5
6
7
8


t1 = y + z
x = t1

->

mov rax, QWORD PTR [rbp-8] ; 将变量 y 加载到寄存器 rax
add rax, QWORD PTR [rbp-16] ; 将变量 z 的值加到 rax 中
mov QWORD PTR [rbp-24], rax ; 将结果 rax 存回变量 x 的内存地址

然后由目标代码优化器对上述目标代码进行优化,比如选择合适的寻址方式,使用位移来代替乘法运算,删除冗余指令等

总结

经过这么多步骤后,源代码被编译成了目标代码,但有一个问题,变量的存储地址还没有确定,而且如果这个变量是来自其他模块的话又该怎么办?这就是链接派上用场的地方了

链接概览

链接有以下几个步骤:

地址和空间分配(Address and Storage Allocation)
符号决议(Symbol Resolution)
重定位(Relocation)

补充: 编译全过程;编译器的前端和后端

由于书上对这些概念没有做一个很清晰的介绍,因此我再在这里做一点辨析方便后续的阅读: 流水线解释

预处理: 转换宏定义,删除注释
编译(狭义): 将cpp源码翻译成汇编代码(人类可读)
汇编:
- 将汇编代码翻译成机器指令(二进制码)
- 根据机器指令,地址位置等信息构造目标文件
链接: 将目标文件与系统库,用户库关联起来,得到可执行文件
编译(广义): 由于大多数人对cpp的装载过程没有一个清晰的认识,故通常使用编译代指从.cpp到.exe的全过程,也就是说我们一般都用广义的编译概念,很少特指"真正的编译"

但是,我们所用的编译器如gcc,clang等都是广义上的编译器,也就是说不仅仅做的是编译,而是包揽了从.cpp到目标文件的全构建过程. 如果用前端和后端的概念来划分的话,是这样的:

前端（Frontend）

范畴： 仅包含“编译”这一步的前半部分。

输入： 预处理后的源码。
任务： 词法分析（Lexical Analysis）、语法分析（Syntax Analysis）、语义分析（Semantic Analysis）、生成中间表示（IR, Intermediate Representation）。
特性： 与具体的硬件架构（如 x86、ARM）无关，只与 C++ 语言本身的规则有关。

后端（Backend）

范畴： 包含“编译”这一步的后半部分，以及“汇编”的全部。

任务： * 中端优化（Optimizer）：对 IR 进行架构无关的优化。
- 代码生成（Code Generator）：将 IR 转换为特定硬件的汇编代码。
- 汇编器（Assembler）：将汇编代码转换为机器指令，产出目标文件。
特性： 强依赖于硬件架构。

其他项

预处理（Preprocessing）：通常被视为编译前的“文本清洁工作”，不属于狭义编译器（Compiler Core）的前后端逻辑。
链接（Linking）：属于编译链的下游，是一个独立的二进制处理过程，不属于编译器（Compiler）的范畴。

目标文件: 汇编的产物

目标文件的格式

可执行文件的格式主要有Windows中的PE(Portable Executable,不是那个重装windows用的Preinstallation Environment)和Linux中的ELF(Executable Linkable Format),两者都是COFF(Common file format)的变种.从广义上看,可执行文件的格式与目标文件基本相同,故这里将它们看作一种类型的文件,在Windows中称为PE-COFF文件格式,在Linux中称为ELF文件格式.(也就是说我们这里把目标文件就看成是ELF文件)

事实上,动态链接库(DLL,Dynamic Linking Library)(Windows.dll和Linux的.so)和静态链接库(Static Linking Library)(Windows的.lib和Linux的.a)的存储方式也是可执行文件.

更为标准的分类方法如下:

ELF 文件类型	说明	实例
可重定向文件 (Relocatable File)	包含代码和数据，可被用来链接成可执行文件或共享目标文件，静态链接库也归为此类。	Linux 的 `.o` Windows 的 `.obj`
可执行文件 (Executable File)	包含可以直接执行的程序。	Linux 的 `/bin/bash` Windows 的 `.exe`
共享目标文件 (Shared Object File)	包含代码和数据。可由链接器与其他可重定向/共享目标文件链接产生新目标文件；或由动态链接器与可执行文件结合，作为进程映像的一部分运行。	Linux 的 `.so` Windows 的 `DLL`
核心转储文件 (Core Dump File)	当进程意外终止时，系统将该进程的地址空间内容及终止时的其他信息转储到该文件。	Linux 下的 `core dump`

ELF文件的内容

目标文件将不同类型的信息用段(section)的形式存储:

File Header: 描述了整个文件的文件属性,包括文件是否可执行,目标硬件,目标操作系统等信息;还包括一个段表(section table),描述目标文件中各段的属性
1. 使用C语言的结构体来定义
.text section: 保存汇编得到的及其代码
.data section: 保存已经初始化的全局变量和局部静态变量
.bss section: 保存未初始化的全局变量和局部静态变量,由于它们都是0,故没有必要放入.data段中,同时,由于程序运行时需要记录这两类变量,因此需要用.bss段来额外预留位置.该段并没有内容,故在目标文件中也不占据空间.

bss的来历 BSS(Block Started by Symbol)来源于1950年代IBM大型机的汇编器中的一个伪指令,后来被引入标准汇编器FAP中,用于定义符号并且为该符号预留给定数量的未初始化空间

整体来说,源代码被编译后分成两段:程序指令(代码段),程序数据(数据段和.bss段).

事实上,ELF文件的内部结构比上述所说的四段式结构要复杂的多:

[ 0] (NULL)：索引为 0 的段物理上必须存在且全为空，用于标识无效引用。
[ 1] .text：代码段。存放程序经过编译后的物理机器指令。
[ 2] .rel.text：代码重定位段。记录 .text 段中哪些物理地址需要在链接时进行修正。
[ 3] .data：已初始化数据段。存放程序中已初始化的全局变量和局部静态变量。
[ 4] .bss：未初始化数据段。为未初始化的全局变量预留的物理占位符，在文件中不占实际磁盘空间。
[ 5] .rodata：只读数据段。存放常量（如字符串常量、const 修饰的变量）。
[ 6] .comment：注释段。物理记录编译器版本信息（如 “GCC: (GNU) …"）。
[ 7] .note.GNU-stack：堆栈属性段。物理标识堆栈是否可执行，用于系统安全防御（NX 位）。
[ 8] .shstrtab：段表字符串表。存储所有段名（如 “.text”, “.data”）的物理字符串池。
[ 9] .symtab：符号表。记录程序中定义和引用的所有函数名、变量名及其物理偏移。
[10] .strtab：字符串表。存储符号表中所使用的所有名称字符串。

下面我们来一个个解析:

文件头,段表,重定位表

文件头

拓展阅读

本书使用的示例c程序分析得到的文件头内容如下:

Magic (魔数)：7f 45 4c 46 01 01 01 00 ...
- 物理意义：文件开头的 16 个字节，用于标识该文件是一个 ELF 格式的可执行或目标文件。
Class (类别)：ELF32
- 物理意义：该文件是为 32 位 架构设计的。
Data (数据存储方式)：2's complement, little endian
- 物理意义：采用二补码形式，且为 小端序（低位字节存储在低地址）。
Version (版本)：1 (current)
- 物理意义：当前 ELF 格式的版本号。
OS/ABI (操作系统/接口)：UNIX - System V
- 物理意义：该文件遵循的物理调用约定标准。
Type (文件类型)：REL (Relocatable file)
- 物理意义：这是一个可重定位文件（通常为 .o 文件），尚未经过链接。
Machine (硬件平台)：Intel 80386
- 物理意义：物理运行的目标指令集架构。
Entry point address (入口地址)：0x0
- 物理意义：由于是可重定位文件，尚未装载，因此物理入口地址为 0。
Start of program headers (程序头起点)：0 (bytes into file)
- 物理意义：目标文件中通常不包含程序头表（Program Header Table），该表仅在可执行文件中存在。
Start of section headers (段表起点)：280 (bytes into file)
- 物理意义：**段表（Section Header Table）**在文件内部的物理偏移地址。
Size of this header (ELF 头大小)：52 (bytes)
- 物理意义：ELF Header 本身物理占据的字节长度。
Size of section headers (单段描述符大小)：40 (bytes)
- 物理意义：段表中每个条目物理占据的空间。
Number of section headers (段的数量)：11
- 物理意义：该文件物理包含 11 个段（如 .text, .data, .bss 等）。
Section header string table index (段表字符串表索引)：8
- 物理意义：存储段名字符串的表在段表中的物理下标。

事实上,这些信息是以C语言的结构体存储的:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


typedef struct {
 unsigned char e_ident[16]; // 物理魔数区（含架构、字节序信息）
 Elf32_Half e_type; // 物理文件类型
 Elf32_Half e_machine; // 物理硬件平台
 Elf32_Word e_version; // 物理版本
 Elf32_Addr e_entry; // 物理程序入口地址
 Elf32_Off e_phoff; // 程序头表物理偏移
 Elf32_Off e_shoff; // 段表物理偏移
 Elf32_Word e_flags; // 处理器标志位
 Elf32_Half e_ehsize; // ELF 头物理大小
 Elf32_Half e_phentsize; // 单个程序头描述符大小
 Elf32_Half e_phnum; // 程序头描述符数量
 Elf32_Half e_shentsize; // 单个段表描述符大小
 Elf32_Half e_shnum; // 段表描述符数量
 Elf32_Half e_shstrndx; // 段名字符串表所在段的索引
} Elf32_Ehdr;

在 ELF 文件格式定义中，为了屏蔽不同平台下 int 或 long 长度不一带来的物理对齐问题，官方定义了一套标准数据类型：

自定义类型	描述	原始类型	长度（字节）
Elf32_Addr	32 位版本程序地址	`uint32_t`	4
Elf32_Half	32 位版本无符号短整型	`uint16_t`	2
Elf32_Off	32 位版本偏移地址	`uint32_t`	4
Elf32_Sword	32 位版本有符号整型	`int32_t`	4
Elf32_Word	32 位版本无符号整型	`uint32_t`	4
Elf64_Addr	64 位版本程序地址	`uint64_t`	8
Elf64_Half	64 位版本无符号短整型	`uint16_t`	2
Elf64_Off	64 位版本偏移地址	`uint64_t`	8
Elf64_Sword	64 位版本有符号整型	`int32_t`	4
Elf64_Word	64 位版本无符号整型	`uint32_t`	4

带上示例来解释:

成员	内容	物理/逻辑解释
e_ident	Magic: 7f 45 4c 46 01 01 01 00…	ELF 魔数。包含文件机器字节长度、数据存储方式、版本、运行平台及 ABI 版本。
e_type	Type: REL (Relocatable file)	ELF 文件类型。标识是可重定位文件、可执行文件还是共享对象文件。
e_machine	Machine: Intel 80386	CPU 平台属性。相关常量以 `EM_` 开头（如 EM_386）。
e_version	Version: 0x1	ELF 版本号。通常为常数 1。
e_entry	Entry point address: 0x0	入口地址。规定程序开始执行的虚拟地址。可重定位文件（.o）通常为 0。
e_phoff	Start of program headers: 0	程序头（Program Header）偏移。在链接视图中暂不关心，执行视图的核心。
e_shoff	Start of section headers: 280	段表（Section Header）偏移。即段表在文件内的起始物理位置。
e_word	Flags: 0x0	ELF 标志位。标识特定平台相关的属性，格式通常为 `EF_machine_flag`。
e_ehsize	Size of this header: 52 (bytes)	ELF 文件头本身的大小。在本例中物理占据 52 字节。
e_phentsize	Size of program headers: 0	程序头描述符的大小。
e_phnum	Number of program headers: 0	程序头描述符的数量。
e_shentsize	Size of section headers: 40 (bytes)	段表描述符的大小。物理上等于 `sizeof(Elf32_Shdr)`。
e_shnum	Number of section headers: 11	段的数量。物理记录了 ELF 文件中拥有的段表描述符总数。
e_shstrndx	Section header string table index: 8	段表字符串表下标。存储段名字符串的表在段表中的物理索引位置。

魔数详解

e_ident成员的前四个字节7f 45 4c 46中,第一个字节对应的是ASCII中的DEL控制符,后三个字节刚好是ELF这三个字母的ASCII码,从而唯一标识了ELF文件,故被称为ELF文件的魔数.

接下来的一个字节用来标识ELF的文件类,01表示是32位的,02表示是64位的;第六个字节是字节序,规定该文件是大端存储还是小端存储;第七个字节为该文件的主版本号,一般是1,因为ELF标准从1.2版后就没有更新过.后面的9个字节ELF标准没有定义,一般填0. 至于为什么要多出来这9个字节,主要是为了兼容老编译器的考量.

自然,所有的可执行文件都有一个魔数用来标识自己,比如PE/COFF文件的最开始两个字节为4d,5a,即ASCII字符MZ.

段表

段表用于保存ELF文件中各个section(段)的基本信息,比如段的名字,长度,存储位置,读写权限等属性.编译器,链接器和装载器都是依靠段表来定位和访问各个段的属性的,至于段表的位置则是由文件头中的e_shoff字段来定义的.

尽管书上讲的很详细,但我想只需要大概知道段表的作用即可

重定位表

链接器在处理目标文件的时候,需要对目标文件中的某些部分进行重定位,即.text段和.data段中对绝对地址引用的位置.

对于每个要重定位的.text段和.data段,都会有一个相应的重定位表.

链接的接口: symbol

如果目标文件B用到了目标文件A中的函数foo,那么就称A定义(define)了foo,B引用(reference)了A中的函数foo.

在链接中,函数和变量统称为符号(symbol),函数名和变量名则为符号名(symbol name).

链接中很关键的一部分就是符号的管理,每一个目标文件都有一个相应的符号表,记录该目标文件中用到的所有符号,每个定义的符号有一个对应的符号值,对于变量和函数来说,符号值就是它们的地址.

除了函数和变量之外，还存在其他几种不常用到的符号。我们将符号表中所有的符号进行分类，它们可能是下面这些类型中的一种：

定义在本目标文件的全局符号，可以被其他目标文件引用。比如 SimpleSection.o 里面的 “func1”、“main” 和 “global_init_var”。
在本目标文件中引用的全局符号，却没有定义在本目标文件，这一般叫做外部符号（External Symbol），也就是我们前面所讲的符号引用。比如 SimpleSection.o 里面的 “printf”。
段名，这种符号往往由编译器产生，它的值就是该段的起始地址。比如 SimpleSection.o 里面的 “.text”、“.data” 等。
局部符号，这类符号只在编译单元内部可见。比如 SimpleSection.o 里面的 “static_var” 和 “static_var2”。调试器可以使用这些符号来分析程序或崩溃时的核心转储文件。这些局部符号对于链接过程没有作用，链接器往往也忽略它们。
行号信息，即目标文件指令与源代码中代码行的对应关系，它也是可选的。

符号修饰与函数签名

在cpp中我们可以通过命名空间(namespace)和函数重载定义多个同名函数,那么编译器和链接器就需要在链接过程中区分这两个函数.

首先,我们可以使用函数签名(function signature)来区分不同的函数,它包含了函数的名字,参数类型,命名空间,所在的类及其他信息.这样可以保证每一个函数都有一个独特的函数签名.

其次,我们可以根据函数签名在编译过程中修饰这些函数,例如:

函数签名	修饰后名称（符号名）
int func(int)	_Z4funci
float func(float)	_Z4funcf
int C::func(int)	_ZN1C4funcEi
int C::C2::func(int)	_ZN1C2C24funcEi
int N::func(int)	_ZN1N4funcEi
int N::C::func(int)	_ZN1N1C4funcEi

自然,cpp中的全局变量和静态变量也有同样的签名和修饰机制,而C语言由于不存在重名机制,故不需要对涉及的符号进行任何修改.

强弱符号

在C/CPP中,函数和初始化的全局变量为强符号(strong symbol),未初始化的全局变量为弱符号(weak symbol).

编译器按照以下三个规则来处理强弱符号:

不允许强符号被多次定义,否则链接器会报出符号重复定义的错误
如果一个符号在某个目标文件中是强符号,在其他目标文件中是弱符号,则将它看作为强符号
如果一个符号在所有目标文件中都是弱符号,那么选择占用空间最大的一个作为它的定义,如int和double中选择double.

强弱引用

当目标文件中引用外部符号时,如果在链接时,没有找到该符号的定义,那么就会报出未定义错误,这类引用被称为强引用(strong reference).

但是还有一类特殊的引用即使在链接时没找到该符号的定义也不报错,被称为弱引用(weak reference).这允许了冗余代码和缺失功能模块的设计.

调试信息

目标文件里还会保存调试信息,如果我们用GCC编译时加上 “-g” 参数，编译器就会在产生的目标文件里面加上调试信息，我们通过 readelf 等工具可以看到，目标文件里多了很多 “debug” 相关的段：

[Nr]	Name	Type	Addr	Off	Size	ES	Flg	Lk	Inf
…
[ 4]	.debug_abbrev	PROGBITS	00000000	000040	000034	00	0	0	1
[ 5]	.debug_info	PROGBITS	00000000	000074	0000af	00	0	0	1
[ 6]	.rel.debug_info	REL	00000000	000738	000038	08	9	5	4
[ 7]	.debug_line	PROGBITS	00000000	000123	000037	00	0	0	1
[ 8]	.rel.debug_line	REL	00000000	000770	000008	08	19	7	4
[ 9]	.debug_frame	PROGBITS	00000000	00015c	000034	00	0	0	4
[10]	.rel.debug_frame	REL	00000000	000778	000010	08	19	9	4
[11]	.debug_loc	PROGBITS	00000000	000190	00002c	00	0	0	1

调试信息在目标文件和可执行文件中占用了很大的空间,往往比程序的代码和数据本身大好几倍,因此,发布程序时,我们需要去除这些对于用户没有用的调试信息,从而节省大量的空间
- 例如可以在VS中选用Release模式而非Debug模式,从而将大部分调试信息排除在打包的可执行文件以外.

静态链接(4/15)

当我们运行gcc -c a.c b.c后,得到两个目标文件a.o和b.o,如何将他们链接起来,形成一个可执行文件?这个过程中发生了什么?

链接方法

对于多个目标文件,链接器有以下两种方法,将他们的各个段(section)合并到一个可执行文件中:

按序叠加
相似段合并

按序叠加

这种方法将输入的目标文件按照次序叠加起来: 显然,这种做法非常浪费空间,会堆积一大堆冗余数据

相似段合并

将相同性质的段合并到一起是一个更为实际的方法,也是主流的链接器空间分配策略: 这种链接方式分为两步:

空间和地址分配: 扫描所有的目标文件,将符号表中的所有信息统一放到一个全局符号表
符号解析和重定位: 根据上一步的信息,进行符号解析和重定位,调整代码中的地址

空间与地址分配

通过 objdump -h 命令观察目标文件 a.o、b.o 以及链接后的可执行文件 ab 的段分配情况：

a.o (目标文件)

Idx	Name	Size	File off	Algn	Flags
0	.text	00000034	00000034	2**2	CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
1	.data	00000000	00000068	2**2	CONTENTS, ALLOC, LOAD, DATA
2	.bss	00000000	00000068	2**2	ALLOC

b.o (目标文件)

Idx	Name	Size	File off	Algn	Flags
0	.text	0000003e	00000034	2**2	CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
1	.data	00000004	00000074	2**2	CONTENTS, ALLOC, LOAD, DATA
2	.bss	00000000	00000078	2**2	ALLOC

ab (链接后的可执行文件)

Idx	Name	Size	VMA	LMA	File off	Algn	Flags
0	.text	00000072	08048094	08048094	00000094	2**2	CONTENTS, ALLOC, LOAD, READONLY, CODE
1	.data	00000004	08049108	08049108	00000108	2**2	CONTENTS, ALLOC, LOAD, DATA

VMA (Virtual Memory Address)：链接前目标文件的 VMA 均为 0，因为尚未物理分配虚拟地址；链接后 ab 中的段被物理分配到了以 0804xxxx 开头的地址空间。
- LMA(Load Memory Address): 装载地址,正常情况下该值与VMA相同,但在部分嵌入式系统中,两个值是不同的.
Size 合并：ab 的 .text 段大小（0x72）约等于 a.o（0x34）与 b.o（0x3e）之和，体现了链接器的段合并策略。
Flags 变化：链接后的 ab 移除了 RELOC 标志，说明物理重定位已完成。

可执行文件里没有物理地址,在执行时才由操作系统将虚拟地址映射到物理地址

符号解析与重定位(4/22)

重定位: 修正编译器产生的符号(函数与变量)地址
符号解析: 根据全局符号表查找所需符号的地址,用于重定位

C++相关的链接问题(待补充)

Windows PE/COFF

之所以叫PE/COFF,是因为windows32位的可执行文件格式PE与ELF一样,都是从古老的COFF格式发展来的.换句话说,PE(Portable Executable)是COFF的一种扩展,结构上大致相同,与ELF格式也基本相同,都采用了段的格式

windows64位中,对原本的PE格式做了一点修改,叫做PE32+,它没有增加新的字段,只是把原来的32位字段变成了64位,因此我们也可以把它看作是一般的PE文件.

总的来说的话,在Windows中目标文件为COFF格式,为.obj后缀;可执行文件/动态链接库为PE格式,为.exe/dll后缀

COFF文件结构

COFF 目标文件格式 (COFF Object File Format) 的常见结构如下：

Image Header (IMAGE_FILE_HEADER)
Section Table (IMAGE_SECTION_HEADER[])
.text（代码节）
.data（数据节）
.drectve（指示节）
.debug$S（调试符号节）
other sections（其他节）
Symbol Table（符号表）

与ELF文件格式确实很像

前两个部分是COFF文件的文件头,分别是描述文件总体结构和属性的映像头和描述各段属性的段表

映像(image): PE文件在装载时会被直接映射到进程的虚拟空间中,是进程虚拟空间的映像.

PE文件结构

PE 文件格式 (PE File Format) 的常见结构如下：

Image DOS Header (IMAGE_DOS_HEADER)
Image DOS Stub
PE File Header (IMAGE_NT_HEADERS)
- Image Header (IMAGE_FILE_HEADER)
- Image Optional Header (IMAGE_OPTIONAL_HEADER32)
Section Table (IMAGE_SECTION_HEADER[])
.text
.data
.drectve
.debug$S
other sections
Symbol Table

第一段和第二段中DOS部分的来历:

在Windows发展的早期,古老的DOS系统还十分盛行,而此时的Windows甚至不能脱离DOS环境独立运行,所以为Windows1编写的程序必须加入这两个DOS段来兼容DOS系统. 为了兼容古老的程序,直到现在的Windows可执行文件都包含了这两个段

Image DOS Header详解

“IMAGE_DOS_HEADER”结构也被定义在 WinNT.h 里面，该结构的大多数成员我们都不关心，唯一值得关心的是“e_lfanew”成员，这个成员表明了 PE 文件头（IMAGE_NT_HEADERS）在 PE 文件中的偏移，我们需要使用这个值来定位 PE 文件头。

这个成员在 DOS 的“MZ”文件格式中的值永远为 0，所以当 Windows 开始执行一个后缀名为“.exe”的文件时，它会判断“e_lfanew”成员是否为 0。如果为 0，则该“.exe”文件是一个 DOS“MZ”可执行文件，Windows 会启动 DOS 子系统来执行它；如果不为 0，那么它就是一个 Windows 的 PE 可执行文件，“e_lfanew”的值表示“IMAGE_NT_HEADERS”在文件中的偏移。

Image DOS Stub详解

当 PE 可执行映像在 DOS 下被加载的时候，DOS 系统检测该文件，发现最开始两个字节是“MZ”，于是认为它是一个“MZ”可执行文件。然后 DOS 系统就将 PE 文件当作正常的“MZ”文件开始执行。

DOS 系统会读取 “e_cs” 和 “e_ip” 这两个成员的值，以跳转到程序的入口地址。然而 PE 文件中，“e_cs”和“e_ip”这两个成员并不指向程序真正的入口地址，而是指向文件中的 “DOS Stub”。

“DOS Stub” 是一段可以在 DOS 下运行的一小段代码，这段代码的唯一作用是向终端输出一行字：

“This program cannot be run in DOS”

然后退出程序，表示该程序不能在 DOS 下运行。所以我们如果在 DOS 系统下运行 Windows 的程序就可以看到上面这句话，这是因为 PE 文件结构兼容 DOS “MZ” 可执行文件结构的缘故。

可执行文件的装载

可执行文件只有装载到内存以后才能被 CPU 执行。早期的程序装载十分简陋，装载的基本过程就是把程序从外部存储器中读取到内存中的某个位置。随着硬件 MMU 的诞生，多进程、多用户、虚拟存储的操作系统出现以后，可执行文件的装载过程变得非常复杂。

进程虚拟地址空间

Transformers快速入门

标题很具有迷惑性,事实上,这篇文章的前面几章深入浅出的讲述了大语言模型(LLM)的前世今生,让人受益匪浅

自然语言处理

这一章的介绍相当精彩,通俗易懂

要让计算机处理自然语言，首先需要为自然语言建立数学模型，这种模型被称为语言模型（Language Model，LM）,其核心思想是判断一个文字序列是否构成人类能理解并且有意义的句子，即建模文本序列的生成概率。

统计语言模型

可以看到,这里的数学原理是非常简单的,并不怎么难懂

即使是使用三元、四元甚至是更高阶的语言模型，依然无法覆盖所有的语言现象。在自然语言中，上下文之间的关联性可能跨度非常大，例如从一个段落跨到另一个段落，这是马尔可夫假设解决不了的。此时就需要使用 LSTM、Transformer 等模型来捕获词语之间的远距离依赖（Long Distance Dependency）了。

神经语言模型

NNLM模型

具体来说，NNLM 模型首先从词表C中查询得到前面N个词语对应的词向量,然后将这些词向量拼接后输入到带有激活函数的隐藏层中，通过Softmax函数预测当前词语的概率,它不仅能够能够根据上文预测当前词语，同时还能够给出所有词语的词向量

Word2Vec模型

Word2Vec 的模型结构和 NNLM 基本一致，只是训练方法有所不同，分为 CBOW (Continuous Bag-of-Words) 和 Skip-gram 两种:

可以看到，与严格按照统计语言模型结构设计的 NNLM 模型不同，Word2Vec 模型在结构设计上更加自由，训练目标也更多是为获得词向量服务。特别是 CBOW 训练方法同时通过上文和下文来预测当前词语，打破了语言模型“只通过上文来预测当前词”的固定思维，为后续一系列神经网络语言模型的发展奠定了基础

预训练语言模型

然而，有一片乌云始终笼罩在 Word2Vec 模型的上空——多义词问题。一词多义是语言灵活性和高效性的体现，但是 Word2Vec 模型却无法处理多义词，一个词语无论表达何种语义，Word2Vec 模型都只能提供相同的词向量，即将多义词编码到完全相同的参数空间。

实际上在 20 世纪 90 年代初，雅让斯基（Yarowsky）就给出了一个简洁有效的解决方案——运用词语之间的互信息（Mutual Information）具体来说，对于多义词，可以使用文本中与其同时出现的互信息最大的词语集合来表示不同的语义。例如对于“苹果”，当表示水果时，周围出现的一般就是“超市”、“香蕉”等词语；而表示“苹果公司”时，周围出现的一般就是“手机”、“平板”等词语

ELMo 模型

为了更好地解决多义词问题，2018 年研究者提出了 ELMo 模型（Embeddings from Language Models）。与 Word2Vec 模型只能提供静态词向量不同，ELMo 模型会根据上下文动态地调整词语的词向量。

但是 ELMo 模型存在两个缺陷：首先它使用 LSTM 模型作为编码器，而不是当时已经提出的编码能力更强的 Transformer 模型；其次 ELMo 模型直接通过拼接来融合双向抽取特征的做法也略显粗糙

GPT 模型

不久之后，OpenAI 将 ELMo 模型中的 LSTM 更换为 Transformer 提出了 GPT 模型（Generative Pre-trained Transformer）。并且 GPT 模型继续追随 NNLM 的脚步，采用仅有解码器的 Transformer 架构，只通过词语的上文进行预测。

虽然解码器架构适合于完成自然语言生成任务（如文本摘要），但是在一定程度上也限制了模型的应用场景，例如对于文本分类、阅读理解等任务，如果不把词语的下文信息也嵌入到词向量中就会白白丢掉很多信息。

BERT 模型

2018 年底，Google 基于 Transformer 模型进一步提出了 BERT 模型（Bidirectional Encoder Representations from Transformers），这一阶段神经网络语言模型的发展终于出现了一位集大成者，BERT 模型在发布时在 11 个任务上都取得了最好性能.

BERT 模型采用和 GPT 模型类似的两阶段框架，首先对语言模型进行预训练，然后通过微调来完成下游任务。但是，BERT 不仅像 GPT 模型一样采用 Transformer 作为编码器，而且采用了类似 ELMo 模型的双向语言模型结构，如图 1-11 所示。因此 BERT 模型不仅编码能力强大，而且对各种下游任务，BERT 模型都可以通过简单地改造输出部分来完成。

大语言模型

除了优化模型结构，研究者发现扩大模型规模也可以提高性能。在保持模型结构以及预训练任务基本不变的情况下，仅仅通过扩大模型规模就可以显著增强模型能力，尤其当规模达到一定程度时，模型甚至展现出了能够解决未见过复杂问题的涌现（Emergent Abilities）能力。例如 175B 规模的 GPT-3 模型只需要在输入中给出几个示例，就能通过上下文学习（In-context Learning）完成各种小样本（Few-Shot）任务，而这是 1.5B 规模的 GPT-2 模型无法做到的。为了区分这两代模型之间的差异，业界将大型预训练语言模型命名为“大语言模型”（Large Language Model，LLM）。

在规模扩展定律（Scaling Laws）被证明对语言模型有效之后，研究者基于 Transformer 结构不断加深模型深度，构建出了许多大语言模型可以说，大语言模型的出现改变了自然语言处理的范式，从为特定 NLP 任务构建专用模型转变为使用单一的大型模型，通过提示或微调来处理各种语言任务，这使得复杂的语言处理更容易实现。相比早期的语言模型主要面向自然语言的建模与生成，最新的语言模型则侧重于复杂任务的求解。从语言建模到任务求解，这是人工智能科学思维的一次重要跃升。

(26/4/15): 尽管直到现在都没人彻底搞明白为什么扩大模型规模就能实现性能的跃升,但还是有很多人都信誓旦旦的认为AI将会取代一切.
- Reddit讨论

Transformer模型

正如第一章所述，自从 BERT 和 GPT 模型取得重大成功之后， Transformer 模型已经替代循环神经网络（RNN）、卷积神经网络（CNN）等传统神经网络结构，成为各种 NLP 模型的标配。

换句话说,出于工程应用的角度,不太有必要去学传统神经网络架构了

Transformer的架构

标准 Transformer 模型主要由**编码器（Encoder）和解码器（Decoder）**两个模块组成其中编码器负责接收输入并构建输入的语义表示（语义特征），从而理解输入内容，而解码器则利用编码器输出的语义表示（语义特征）以及前序输出来生成目标序列。

Transformer模型分类

纯编码器模型（Encoder-Only） 只包含编码器部分，采用双向语言建模，从两个方向理解上下文。适合需要深度理解文本的任务，例如文本分类、命名实体识别等，典型代表如 BERT。
纯解码器模型（Decoder-Only） 只包含解码器部分，从左到右处理文本。尤其擅长文本生成任务，可以根据提示完成句子、撰写文章，甚至生成代码，典型代表如 GPT、Llama。
- 大多数大语言模型（LLM）都采用纯解码器架构，这些模型在过去的几年中规模和功能都得到了显著提升，一些最大的模型包含数千亿个参数。
编码器-解码器模型（Encoder-Decoder） 结合了编码器和解码器，使用编码器理解输入，解码器生成输出。擅长序列到序列任务，例如翻译、摘要、问答等，典型代表如 T5、BART。

大语言模型的工作原理

推理是指大语言模型利用训练中积累的知识，根据给定的输入提示逐字逐句地生成生成类似人类语言文本的过程。具体来说，大语言模型会按照顺序生成的方式，利用从数十亿个参数中学习到的概率来预测和生成序列中的下一个词元（Token），从而生成连贯且与上下文相关的文本。

注意力的作用

注意力机制赋予大语言模型理解上下文并生成连贯响应的能力，在预测下一个词时，句子中的每个词并非都具有相同的权重。例如，在句子“法国的首都是……”中，“法国”和“首都”这两个词对于确定下一个词是“巴黎”至关重要.

这种识别最相关词以预测下一个词元的方法已被证明非常有效。简而言之，注意力机制是语言模型能够生成既连贯又具有上下文感知能力的文本的关键，它也是使现代语言模型区别于前几代语言模型的关键

想要了解大语言模型实际能够处理多少上下文信息，就需要引出上下文长度，或者说模型的“注意力跨度”。上下文长度是指大语言模型一次可以处理的最大词元数量，这会受到模型的架构和尺寸、可用计算资源以及输入和期望输出的复杂性等多个因素的限制。

当我们向大语言模型传递信息时，会以某种方式组织输入以引导模型生成所需的输出，这被称为提示词工程（Prompting）。由于模型的主要任务就是通过注意力机制分析每个输入词元的重要性来预测下一个词元，因此输入序列的措辞至关重要。相比口语化的简单任务描述，精心设计的提示（Prompt）可以更容易地引导大语言模型生成符合预期的输出。

两阶段推理过程

大语言模型生成文本的过程主要分为两个阶段：预填充（Prefill）和解码.

预填充阶段就像烹饪中的准备阶段，所有初始食材都在此阶段进行加工和准备，该阶段包含三个关键步骤：

分词（Tokenization）：将输入文本转换为模型可以理解的基本语言单元——词元(token)。
嵌入转换（Embedding Conversion）：将词元转换为能够表示其语义的密集嵌入表示。
初始处理：将这些嵌入向量输入模型的神经网络，以深入了解上下文。

这个阶段计算量很大，因为模型需要一次性处理完所有输入的词元，就像人类在回复消息之前，先需要阅读并理解消息中的所有文字。

预填充阶段处理完输入后，就进入实际生成文本的解码阶段。在这个阶段，模型会逐个生成词元以构建完整的输出，称之为自回归过程（每个新词元都依赖于所有先前的词元）。这一阶段包含了针对每个新词元执行的多个关键步骤：

注意力计算：回顾所有先前的词元以理解上下文；
概率计算：确定下一个可能出现的词元的概率；
词元选择：根据这些概率选择下一个词元；
持续性检查：决定是否继续或停止生成。

此阶段会占用大量内存，因为模型需要跟踪所有先前已经生成的词元以及它们之间的关系。

采样策略

在模型生成过程中，就像作家可以选择更具创意还是更精确一样，我们也可以调整模型选择词元的方式。当模型生成下一个词元时，它首先会得到词汇表中每个词的原始概率（称为logits），然后基于这些概率来选择下一个词元，这个过程包含以下几个步骤:

原始概率：可以将其视为模型对每个可能的下一个词的初始直觉。
温度控制（Temperature Control）：就像控制创造力的旋钮，设置较高的值（>1.0）会使选择更随机、更具创造性，而较低的值（<1.0）则会使选择更集中、更具确定性。
Top-p 采样（核采样）：不考虑所有可能的词语，而是只关注那些概率总和达到选定阈值的最可能词语（例如前 90%）。
Top-k 过滤：一种替代方法，只考虑最有可能的 k 个下一个词。

此外，大语言模型面临的一个常见挑战是重复性问题，即生成重复的内容。为了解决这个问题，通常可以采用两种惩罚机制:

出现惩罚（Presence Penalty）：对任何已出现过的词元，无论其出现频率如何都施加固定惩罚，从而防止模型重复使用相同的词；
频度惩罚（Frequency Penalty）：根据词元使用频率递增的惩罚机制，一个词出现得越多，再次被选中的可能性就越小。

这些惩罚项会在词元选择的早期阶段就被应用，从而在其他采样策略实施之前就调整原始概率。可以被视为一种温和的引导，鼓励模型探索新的词汇。

最后，考虑到局部最优解未必是全局最优解，如果每次只是简单地选择当前最合适的词元，未必能获得全局质量最好的生成结果，因此还可以使用束搜索（Beam search），同时生成多个词元序列，最后选择总体概率最高的作为最终输出:

在每个步骤中，维护多个候选序列（通常为 5-10 个）。
对于每个候选词，计算其成为下一个词元的概率；
只保留最可能的序列和后续词元组合；
重复此过程，直至达到所需长度或停止；
选择总体概率最高的序列作为输出。

束搜索通常能生成更连贯、语法更正确的文本，但需要更多的计算资源。

但它其实也是局部最优解,要想输出更合理的答案就可以根据之前所说的调整温度和引入惩罚机制

实际挑战与优化

在实际部署大模型时，通常需要考虑以下几个关键指标：

首次响应时间（Time to First Token，TTFT）：获得首次响应的时间，这主要受预填充阶段的影响，对于用户体验非常重要。
输出每词元所需时间（Time Per Output Token，TPOT）：用户衡量生成后续词元的速度，这决定了整体生成速度。
吞吐量（Throughput）：可以同时处理的请求数量。
显存使用情况：GPU 显存的消耗量，这通常会成为实际应用中的主要瓶颈。

此外，有效管理上下文长度是大语言模型推理中最具挑战性的问题之一。虽然更长的上下文可以提供更多信息，但也会带来巨大的成本：内存使用量通常随上下文长度呈二次方增长，而处理速度则通常随上下文长度呈线性下降。例如像 Qwen2.5-1M 这样的新模型支持数百万个 token 的上下文窗口，但这也导致推理速度显著降低，因此关键在于找到适合实际场景的最佳平衡点。

为了应对这些挑战，最有效的优化方法之一是 KV 缓存（Key-Value Caching），通过存储和重用中间计算结果来提高推理速度。这项优化可以减少重复计算，从而提升生成速度，使长上下文生成成为可能。虽然代价是会占用更多内存，但性能提升通常远远超过这一成本。

Transformer详解

都是latex公式,就不摘抄了由于太过专业,因此我自己找AI通俗化了一下:

注意力是什么

注意力机制（Attention Mechanism）的本质是资源的最优分配。它让模型学会从大量信息中，筛选出对当前任务最关键的少数核心信息。

1. 核心逻辑：图书馆借书

要理解注意力，最经典的模型是 Query（查询）、Key（键）、Value（值）。你可以将其想象成在图书馆找书：

Query (Q)：你想找的东西。比如你脑子里的搜索词：“人工智能的历史”。
Key (K)：书架上每本书的标签/书名。模型会计算你的 Query 和每一个 Key 的匹配程度（相关性）。
Value (V)：书里的具体内容。

操作流程：

你拿着 Q 去跟所有的 K 比对，发现《AI简史》匹配度 0.9，《高等数学》匹配度 0.1。
这个匹配度就是权重（Attention Weight）。
最后你带走的知识，就是根据权重加权后的结果：0.9 x 《AI简史》的内容 + 0.1 x 《高数》的内容。

2. 为什么需要它？（对比传统方法）

在注意力机制出现之前，机器处理信息像吞枣：

传统模型（如 RNN）：像一个记性不太好的翻译官。读完一个长句后，他试图把所有信息压缩成一个固定长度的向量。结果就是：读到句尾，句头的信息就模糊了。
注意力模型：像一个带着荧光笔的读者。在处理每个词时，它会瞬间扫描全句，把相关的重点划出来。

3. 不同的注意力类型

自注意力（Self-Attention）：自己跟自己找关系。
- 例子：句子“它在马路上跑，因为它累了”。当处理第二个“它”时，注意力机制会高亮“跑”和“马路”，从而让模型明白这个“它”是指那个运动的物体。
交叉注意力（Cross-Attention）：在两个不同序列间找关系。
- 例子：翻译时。当准备输出英文单词 “Apple” 时，解码器会去中文原句里寻找权重最高的词——“苹果”。

深入理解注意力机制

Transformer 能够“一眼读完全文”且不丢失信息，主要靠的是位置编码和全连接的并行架构。

1. 为什么它能“一眼读完”？

传统的 RNN 像排队进场，信息必须一个接一个传递，前面的信息在传递过程中会像“传声筒游戏”一样逐渐失真。

Transformer 像航拍全景。它利用矩阵运算，在计算的第一步就让序列中所有的词同时进入模型。

物理机制：在自注意力层，每个词都会和全场所有词建立连接。从第 1 个词到第 1000 个词的距离，在矩阵里永远是 $1$。
无损传输：因为不存在“中间商”传递，信息是直接从 A 点点对点触达到 B 点的。

2. 既然是一眼读完，怎么知道谁先谁后？

如果只是把词丢进去，模型会觉得“我吃鱼”和“鱼吃我”是一样的。为了解决这个问题，它引入了位置编码（Positional Encoding）。

硬性叠加：在词向量进入模型之前，会加上一个代表位置的“指纹”。这个指纹是用余弦和正弦函数生成的独特数值序列。
坐标系化：这就好比给每个进场的词发了一个带编号的座位号。
- “我”带上了一个“我是第1位”的属性；
- “鱼”带上了一个“我是第3位”的属性。
特征融合：模型在处理时，不仅能看到“鱼”的含义，还能感知到它携带的“第3位”这个特征。

3. 为什么信息不会丢失？

信息丢失通常发生在“压缩”阶段。Transformer 采用以下手段锁定信息：

全连接注意力（All-to-All）：每一个词在每一层都有机会重新审视全句。即使在第 10 层，它依然可以直接调用第 1 层输入的原始位置信息和语义信息。
残差连接（Residual Connection）：这是最关键的**“保底机制”**。
- 每一层加工完后，都会把“加工前的原始数据”直接加到“加工后的数据”上。
- 这相当于给信息铺设了多条高速公路。如果某一层加工坏了，原始信息可以直接跳过加工层往后传。

Transformer概览

Transformer 的核心逻辑是放弃了“排队处理数据”，改用全连接矩阵并行运算。它将语言处理变成了一个空间几何问题：通过计算词与词之间的距离和权重，捕捉语义。

1. 输入层：数据数字化

计算机不认识文字，第一步是向量化（Embedding）。

词嵌入（Embedding）：将每个词映射到一个高维空间的坐标（向量）。意思相近的词，坐标距离更近。
位置编码（Positional Encoding）：由于 Transformer 是同时读入所有词，它无法区分语序。我们必须给每个词的向量叠加上一个“位置指纹”（通常使用正弦/余弦函数生成），让模型知道谁在谁前面。

2. 核心机制：自注意力（Self-Attention）

这是 Transformer 的“灵魂”。它解决了**“联系”**的问题。

计算逻辑：每个词都生成三个身份：Q（查询）、K（键）、V（值）。
物理过程：
1. 每个词拿自己的 Q 去跟全场所有词的 K 做点积，算出匹配度。
2. 匹配度经过 Softmax 变成权重（比如 0.8、0.1…）。
3. 根据权重去提取对应的 V（值）。
本质：它让每个词在处理时，都能根据上下文自动聚焦到相关的词上。比如在“他过马路”中，“他”会通过注意力强力连接到语境中的具体人物。

3. 编码器（Encoder）：特征提取

编码器由 $N$ 个相同的块堆叠而成。

多头机制（Multi-Head）：并行运行多组自注意力，一组看语法，一组看逻辑，类似于多个人从不同角度审题。
残差连接（Residual）与归一化（Norm）：每一层加工完都会把原始输入加回来，防止深层网络信息丢失或梯度消失。
前馈网络（FFN）：对注意力提取的信息进行非线性转换，进一步强化特征。

4. 解码器（Decoder）：序列生成

解码器负责预测下一个词，它比编码器多了两样东西：

掩码注意力（Masked Attention）：训练时把后面的词遮住，强制模型只能根据已有的上文预测未来。
交叉注意力（Cross-Attention）：解码器会去“盯着”编码器输出的特征矩阵。就像写作文时，一边写（解码），一边看题目要求（编码器的输出）。

5. 输出层：概率映射

线性层：将解码器的输出映射回词表大小。
Softmax：将数值转换为概率。概率最高的那个词，就是模型认为的“下一个词”。

总结：Transformer 为什么强大？

并行性：不再像 RNN 那样一个字一个字读，大大缩短了训练时间。
长程依赖：因为是全连接，句子开头和结尾的词距离永远是 $1$，不会遗忘。
可扩展性：支持模型做大（Scaling Law），参数越多，学到的世界知识就越深邃。

现在的 LLM（如 GPT 系列）多采用 Decoder-Only 架构，即去掉了显式的编码器，让解码器自己处理输入并直接续写。

编码器是什么

将编码器（Encoder）想象成一个**“深度阅读理解器”**。它的任务是将一串单词，通过层层理解，翻译成机器能懂的“思想地图”。

1. 零件拆解：它由什么组成？

如果把编码器比作一个加工车间，它主要有三个工位：

特种雷达（自注意力机制）：每个词都在扫描全场。比如读到“苹果”这个词，雷达会看周围有没有“好吃”或者“乔布斯”。如果有“乔布斯”，它就把“苹果”理解为科技公司；如果有“好吃”，它就理解为水果。
多角度摄像头（多头机制）：不只用一个雷达，而是用 8 个或更多。有的看语法，有的看语气，有的看逻辑，最后汇总。
深加工机床（前馈网络）：雷达看清关系后，机床会对每个词的特征进行非线性强化，把零散的信号固定成深刻的记忆。

2. 运作流程：数据是怎么走的？

打标签（位置编码）：Transformer 是一眼看完一整行字的，为了不让它分不清词序，进门前先给每个词贴个“我是第1个”、“我是第2个”的编号。
找关系（注意力计算）：每个词伸出无数条线连接其他词，根据关联程度分配权重。
加总与校准（残差与归一化）：算完之后，把原始信息和加工后的信息加在一起（怕算丢了），然后把数值拉回到一个标准范围，防止网络“走火入魔”。

3. 本质区别：为什么它更强？

RNN（老方法）：像一个学生背课文，读了后面忘前面，且必须一个字一个字读。
Encoder（新方法）：像摄影师拍全景。一眼望去，所有的词同时入画，所有的联系瞬间建立。

4. 结论

编码器的最终输出不是词，而是一组有“灵魂”的向量。这些向量已经不再是孤立的符号，而是吸收了整句话上下文精华的特征集合。

解码器是什么

1. 结构本质：一个“定向生成器”

如果说编码器是理解全文，解码器（Decoder）则是根据理解，逐字产出。它在编码器的基础上多了一个关键组件：交叉注意力（Cross-Attention）。

2. 核心工作机制

带掩码的自注意力（Masked Self-Attention）：
- 物理约束：生成时，模型不能“偷看”未来的词。
- 实现：通过掩码（Mask）屏蔽掉当前时刻之后的词，确保预测第 $n$ 个词时，只参考前 $n-1$ 个词。
交叉注意力（Cross-Attention）：
- 桥梁作用：这是解码器最核心的工位。它一边看着已经生成的词，一边盯着编码器传过来的“思想地图”（特征向量）。
- 逻辑：它在问编码器：“根据你刚才理解的原文，我现在写到这一步了，下一步最该接哪个信息？”
线性层与 Softmax：
- 将高维向量映射到词表大小的维度，通过概率分布选出得分最高的词。

3. 数据流向：从“过去”和“原文”中找答案

输入：输入的是已经生成出来的词（起始符或前文）。
自我对齐：通过 Masked Attention 整理已生成内容的逻辑。
吸取原文：通过 Cross-Attention 强行去对齐原文的重点。
预测输出：产出一个概率，选出一个词，然后把这个词再丢回输入端，循环往复。

4. 通俗比喻：像是在写“命题作文”

编码器（出题人）：把复杂的背景资料读完，提炼出一张写满考点的纸。
解码器（考生）：
- 他右手拿着已经写好的半篇作文（已生成的词）；
- 左手按着出题人的考点纸（编码器输出）；
- 他一边看左手确认别跑题，一边看右手确认逻辑连贯，最后写出下一个字。

新型模型架构

混合专家架构（Mixture-of-Experts，MoE）: 将Transformer模块中的特定前馈层替换成MoE层,即换成具有不同权重参数的独立网络(称为专家),对于每次输入,选取概率最高的k个专家进行激活,然后加权输出
状态空间模型（State Space Model，SSM）: 试图取代Transformer模型,性能依然有差距,代表模型有RetNet,Mamba等.

Transformer库使用

Transformers 库将目前的 NLP 任务归纳为几下几类：

文本分类：例如情感分析、句子对关系判断等；
对文本中的词语进行分类：例如词性标注 (POS)、命名实体识别 (NER) 等；
文本生成：例如填充预设的模板 (prompt)、预测文本中被遮掩掉 (masked) 的词语；
从文本中抽取答案：例如根据给定的问题从一段文本中抽取出对应的答案；
根据输入文本生成新的句子：例如文本翻译、自动摘要等。

Transformers 库最基础的对象就是 pipeline() 函数，它封装了预训练模型和对应的前处理和后处理环节。我们只需输入文本，就能得到预期的答案。目前常用的 pipelines 有：

feature-extraction：获得文本的向量化表示
fill-mask：填充被遮盖的词、片段
ner：命名实体识别
question-answering：自动问答
sentiment-analysis：情感分析
summarization：自动摘要
text-generation：文本生成
translation：机器翻译
zero-shot-classification：零训练样本分类

情感分析

断更原因

后面的论述和代码过于专业了,不是我现在能看得懂的,显然这并不是真正的快速入门.

设计数据密集型应用

数据系统

数据系统有以下几个作用:

存储数据，以便自己或其他应用程序之后能再次找到（数据库，即 databases）
记住开销昂贵操作的结果，加快读取速度（缓存，即 caches）
允许用户按关键字搜索数据，或以各种方式对数据进行过滤（搜索索引，即 search indexes）
向其他进程发送消息，进行异步处理（流处理，即 stream processing）
定期处理累积的大批量数据（批处理，即 batch processing）因此,常规的数据库,消息队列等信息处理系统都可以被归类为数据系统.

我们可以从三个维度来评价一个数据系统写的怎么样:

可靠性: 出了故障仍然可以正常运行
可伸缩性: 能够应付系统的扩大和其他变化
可维护性: 架构清晰,职责分明,方便维护

可靠性

处理硬件故障

当想到系统失效的原因时，硬件故障（hardware faults）总会第一个进入脑海。硬盘崩溃、内存出错、机房断电、有人拔错网线…… 任何与大型数据中心打过交道的人都会告诉你：一旦你拥有很多机器，这些事情总会发生！

我们可以通过硬件冗余(redundancy of hardware)来解决这个问题,即提供后备组件来及时接替故障硬件,防止系统崩溃.

软件故障

软件故障有以下几个例子:

接受特定的错误输入，便导致所有应用服务器实例崩溃的 BUG。例如 2012 年 6 月 30 日的闰秒，由于 Linux 内核中的一个错误，许多应用同时挂掉了。
级联故障，一个组件中的小故障触发另一个组件中的故障，进而触发更多的故障

管理员的失误导致的故障

一项关于大型互联网服务的研究发现，运维配置错误是导致服务中断的首要原因，而硬件故障（服务器或网络）仅导致了 10-25% 的服务中断

可伸缩性

系统今天能可靠运行，并不意味未来也能可靠运行。服务降级（degradation）的一个常见原因是负载增加，例如：系统负载已经从一万个并发用户增长到十万个并发用户，或者从一百万增长到一千万。也许现在处理的数据量级要比过去大得多

负载: 以推特为例

以推特在 2012 年 11 月发布的数据为例,推特的两个主要业务是：

发布推文
- 用户可以向其粉丝发布新消息（平均 4.6k 请求 / 秒，峰值超过 12k 请求 / 秒）。
主页时间线
- 用户可以查阅他们关注的人发布的推文（300k 请求 / 秒）。

大体上讲，这一对操作有两种实现方式。

发布推文时，只需将新推文插入全局推文集合即可。当一个用户请求自己的主页时间线时，首先查找他关注的所有人，查询这些被关注用户发布的推文并按时间顺序合并。在如图 1-2 所示的关系型数据库中，可以编写这样的查询：

1
2
3
4
5


SELECT tweets.*, users.*
 FROM tweets
 JOIN users ON tweets.sender_id = users.id
 JOIN follows ON follows.followee_id = users.id
 WHERE follows.follower_id = current_user

为每个用户的主页时间线维护一个缓存，就像每个用户的推文收件箱。当一个用户发布推文时，查找所有关注该用户的人，并将新的推文插入到每个主页时间线缓存中。因此读取主页时间线的请求开销很小，因为结果已经提前计算好了。

推特的第一个版本使用了方法 1，但系统很难跟上主页时间线查询的负载。所以公司转向了方法 2，方法 2 的效果更好，因为发推频率比查询主页时间线的频率几乎低了两个数量级，所以在这种情况下，最好在写入时做更多的工作，而在读取时做更少的工作。

然而方法 2 的缺点是，发推现在需要大量的额外工作。平均来说，一条推文会发往约 75 个关注者，所以每秒 4.6k 的发推写入，变成了对主页时间线缓存每秒 345k 的写入。但这个平均值隐藏了用户粉丝数差异巨大这一现实，一些用户有超过 3000 万的粉丝，这意味着一条推文就可能会导致主页时间线缓存的 3000 万次写入！及时完成这种操作是一个巨大的挑战 —— 推特尝试在 5 秒内向粉丝发送推文。

推特轶事的最终转折：现在已经稳健地实现了方法 2，推特逐步转向了两种方法的混合。大多数用户发的推文会写入其粉丝主页时间线缓存中。但是少数拥有海量粉丝的用户（即名流）会被排除在外。当用户读取主页时间线时，分别地获取出该用户所关注的每位名流的推文，再与用户的主页时间线缓存合并

如何处理负载

适应某个级别负载的架构不太可能应付 10 倍于此的负载。如果你正在开发一个快速增长的服务，那么每次负载发生数量级的增长时，你可能都需要重新考虑架构 —— 或者更频繁。

大规模的系统架构通常是应用特定的 —— 没有一招鲜吃遍天的通用可伸缩架构（不正式的叫法：万金油（magic scaling sauce））。应用的问题可能是读取量、写入量、要存储的数据量、数据的复杂度、响应时间要求、访问模式或者所有问题的大杂烩。

举个例子，用于处理每秒十万个请求（每个大小为 1 kB）的系统与用于处理每分钟 3 个请求（每个大小为 2GB）的系统看上去会非常不一样，尽管两个系统有同样的数据吞吐量。

可维护性

众所周知，软件的大部分开销并不在最初的开发阶段，而是在持续的维护阶段，包括修复漏洞、保持系统正常运行、调查失效、适配新的平台、为新的场景进行修改、偿还技术债和添加新的功能。

数据模型

多数应用使用层层叠加的数据模型构建。对于每层数据模型的关键问题是：它是如何用低一层数据模型来表示的？例如：

作为一名应用开发人员，你观察现实世界（里面有人员、组织、货物、行为、资金流向、传感器等），并采用对象或数据结构，以及操控那些数据结构的 API 来进行建模。那些结构通常是特定于应用程序的。
当要存储那些数据结构时，你可以利用通用数据模型来表示它们，如 JSON 或 XML 文档、关系数据库中的表或图模型。
数据库软件的工程师选定如何以内存、磁盘或网络上的字节来表示 JSON / XML/ 关系 / 图数据。这类表示形式使数据有可能以各种方式来查询，搜索，操纵和处理。
在更低的层次上，硬件工程师已经想出了使用电流、光脉冲、磁场或者其他东西来表示字节的方法。

握一个数据模型需要花费很多精力（想想关系数据建模有多少本书）。即便只使用一个数据模型，不用操心其内部工作机制，构建软件也是非常困难的。然而，因为数据模型对上层软件的功能（能做什么，不能做什么）有着至深的影响，所以选择一个适合的数据模型是非常重要的。

关系模型VS文档模型

关系模型曾是一个理论性的提议，当时很多人都怀疑是否能够有效实现它。然而到了 20 世纪 80 年代中期，关系数据库管理系统（RDBMSes）和 SQL 已成为大多数人们存储和查询某些常规结构的数据的首选工具。关系数据库已经持续称霸了大约 25~30 年 —— 这对计算机史来说是极其漫长的时间。

关系数据库起源于商业数据处理，在 20 世纪 60 年代和 70 年代用大型计算机来执行。从今天的角度来看，那些用例显得很平常：典型的事务处理（将销售或银行交易，航空公司预订，库存管理信息记录在库）和批处理（客户发票，工资单，报告）。

NoSQL

采用 NoSQL 数据库的背后有几个驱动因素，其中包括：

需要比关系数据库更好的可伸缩性，包括非常大的数据集或非常高的写入吞吐量
相比商业数据库产品，免费和开源软件更受偏爱
关系模型不能很好地支持一些特殊的查询操作

常见的NoSQL数据库有以下几个:

Redis: 基于内存的存储,核心逻辑是哈希表
MongoDB: 存储格式为JSON

文档和关系数据库的融合

随着时间的推移，关系数据库和文档数据库似乎变得越来越相似，这是一件好事：数据模型相互补充，如果一个数据库能够处理类似文档的数据，并能够对其执行关系查询，那么应用程序就可以使用最符合其需求的功能组合。

(26/4/7): 我发现这本书我现在看太早了,很难有切实的收获,还是等几年再来探索吧

Docker 从入门到实践

比官方文档要简洁清晰的多

入门部分

Docker简介

无论你的应用是用 Python、Java、Node.js 还是其他语言写的，无论它需要什么样的依赖库和环境，一旦被打包成 Docker 镜像，就可以用同样的方式在任何支持 Docker 的机器上运行.

也就是说,通过将依赖和软件打包在一起,我们成功实现了无缝的跨环境运行

Docker不是虚拟机

传统虚拟机技术是虚拟出一套完整的硬件，在其上运行一个完整的操作系统，再在该系统上运行应用

而 Docker 容器内的应用直接运行于宿主的内核，容器内没有自己的内核，也没有进行硬件虚拟

Docker历史

Docker 最初是 dotCloud 公司创始人 Solomon Hykes 在法国期间发起的一个公司内部项目，于 2013 年 3 月以 Apache 2.0 授权协议开源

很难想象这么优秀的技术竟然只有十年多一点的历史

Docker的核心优势

环境一致性

Docker 镜像包含了应用运行所需的一切：代码、运行时、系统工具、库、配置。这意味着:

开发环境和生产环境完全一致
不会再有 “在我机器上能跑” 的问题

快速启动

传统虚拟机启动需要几分钟 (引导操作系统)，而 Docker 容器启动通常只需要几秒甚至几百毫秒

当然这得要你先构建好了镜像和容器

Docker 的核心价值可以用一句话概括：让应用的开发、测试、部署保持一致，同时极大提高资源利用效率。笔者认为，对于现代软件开发者来说，Docker 已经不是 “要不要学” 的问题，而是必备技能。无论你是前端、后端、运维还是全栈开发者，掌握 Docker 都能让你的工作更高效。

基本概念

Docker里有三个基本概念:

镜像(Image): Docker 镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数 (如匿名卷、环境变量、用户等)。镜像不包含任何动态数据，其内容在构建之后也不会被改变。
容器 (Container)：镜像 (Image) 和容器 (Container) 的关系，就像是面向对象程序设计中的类和实例一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
仓库 (Repository)：镜像构建完成后，可以很容易的在当前宿主机上运行，但是，如果需要在其它服务器上使用这个镜像，我们就需要一个集中的存储、分发镜像的服务，Docker Registry 就是这样的服务。

镜像

Docker 镜像是一个只读的模板，包含了运行应用所需的一切：代码、运行时、库、环境变量和配置文件。如果用一个类比：镜像就像是一张光盘或 ISO 文件。你可以用同一张光盘在不同电脑上安装系统，而光盘本身不会被修改。同样，一个镜像可以创建多个容器，而镜像本身保持不变。

镜像的组成部分

类别	示例
程序文件	应用二进制文件、Python/Node 解释器
库文件	libc、OpenSSL、各种依赖库
配置文件	nginx.conf、my.cnf 等
环境变量	PATH、LANG 等预设值
元数据	启动命令、暴露端口、数据卷定义

镜像是只读的
镜像不包含动态数据
镜像构建后内容不会改变

镜像的分层存储

1
2
3
4
5
6
7
8


FROM ubuntu:24.04 
# 第 1 层：基础系统（约 78MB）
RUN apt-get update 
# 第 2 层：更新包索引
RUN apt-get install nginx 
# 第 3 层：安装 nginx
COPY app.conf /etc/nginx/ 
# 第 4 层：复制配置文件

换句话说,只要某一行命令对镜像做了修改,就被docker视为单独的一个构建层,不可以被其他构建层修改,但可以与其他镜像共享

镜像标识

镜像名称和标签

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


## 完整格式

registry.example.com/myproject/myapp:v1.2.3

## 简写（使用 Docker Hub）

nginx:1.25
ubuntu:24.04

## 省略标签（默认使用 latest）

nginx 
# 等同于 nginx:latest

镜像ID

1
2
3
4


$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx latest a6bd71f48f68 2 weeks ago 187MB
ubuntu 24.04 ca2b0f26964c 3 weeks ago 78.1MB

镜像摘要 镜像摘要是基于镜像内容生成的哈希码

1
2
3


$ docker images --digests
REPOSITORY TAG DIGEST IMAGE ID
nginx latest sha256:6db391d1c0cfb30588ba0bf72ea999404f2764184d8b8d10d89e8a9c6... a6bd71f48f68

容器

容器是镜像的运行实例。如果把镜像比作程序，那么容器就是进程。用面向对象编程的术语来说：镜像是类 (Class)，容器是对象 (Instance)。

容器的本质

笔者认为，理解这一点是理解 Docker 的关键：容器的本质是一个特殊的进程

这种隔离是通过 Linux 内核的 Namespace 技术实现的。具体表现为：

进程空间：容器看不到宿主机上的其他进程。
网络：容器拥有独立的 IP、端口等网络资源
文件系统：容器拥有独立的 root 目录。
用户：容器内的 root 用户不等于宿主机的 root 用户。

容器的存储层机制

当容器运行时，Docker 会在镜像的只读层之上创建一个可写层(容器存储层);

而当容器需要修改镜像层中的文件时:

Docker将该文件复制到容器存储层
在容器存储层中进行修改
原始镜像层保持不变

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


## 创建容器，写入数据

$ docker run -it ubuntu bash
root@abc123:/# echo "important data" > /data.txt
root@abc123:/# exit

## 删除容器

$ docker rm abc123

## 数据丢了！没有任何办法恢复！

既然当容器被删除后数据就全部丢失,那么容器存储层就不应该保留任何重要的信息,而是只保留运行时数据.

如果我们想要存储数据,可以使用数据卷(Volume)来存储数据库和应用数据,或者使用绑定到宿主机的目录.

1
2
3
4
5
6
7
8


## 使用数据卷（推荐）

$ docker run -v mydata:/var/lib/mysql mysql

## 使用绑定挂载

$ docker run -v /host/path:/container/path nginx
# 这些位置的读写会跳过容器存储层，直接写入宿主机，性能更好，也不会随容器删除而丢失

容器的生命周期

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


## 创建并启动容器（最常用）

$ docker run nginx

## 分步操作

$ docker create nginx # 创建容器（不启动）
$ docker start abc123 # 启动容器

## 停止容器

$ docker stop abc123 # 优雅停止（发送 SIGTERM，等待后发送 SIGKILL）
$ docker kill abc123 # 强制停止（直接发送 SIGKILL）

## 暂停/恢复（不常用，但有时有用）

$ docker pause abc123 # 暂停容器内所有进程
$ docker unpause abc123 # 恢复

## 删除容器

$ docker rm abc123 # 删除已停止的容器
$ docker rm -f abc123 # 强制删除运行中的容器

仓库

Docker Registry 是存储和分发 Docker 镜像的服务，类似于代码的 GitHub 或包管理的 npm。

Docker Registry 中可以包含多个 Repository，每个 Repository 可以包含多个 Tag:

概念	说明	示例
Registry	存储镜像的服务	Docker Hub、ghcr.io
Repository (仓库)	同一软件的镜像集合	nginx、mysql、mycompany/myapp
Tag (标签)	仓库内的版本标识	latest、1.25、alpine

一个完整的 Docker 镜像名称由 Registry 地址、用户名/组织名、仓库名和标签组成。了解其结构有助于我们更准确地定位镜像。基本格式如下： [registry 地址/][用户名/]仓库名[:标签] 完整示例如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


registry.example.com/mycompany/myapp:v1.2.3
│ │ │ │
│ │ │ └── 标签
│ │ └── 仓库名
│ └── 用户名/组织名
└── Registry 地址

## Docker Hub 官方镜像（省略 registry 和用户名）

nginx:1.25
ubuntu:24.04

## Docker Hub 用户镜像

jwilder/nginx-proxy:latest

## 其他 Registry

ghcr.io/username/myapp:v1.0
gcr.io/google-containers/pause:3.10

公共 Registry

Docker Hub 是最大的公共 Registry，也是 Docker 的默认 Registry,有以下特点:

拥有大量官方镜像(nginx、mysql、redis)
免费账户可以创建公开仓库
付费账户支持私有仓库

除了 Docker Hub，还有以下几个常见的公共 Registry：

Registry	地址	说明
GitHub Container Registry	ghcr.io	GitHub 提供，与 GitHub Actions 集成好
Google Container Registry	gcr.io	Google Cloud 提供，Kubernetes 镜像常用
Quay.io	quay.io	Red Hat 提供
阿里云容器镜像服务	registry.cn-*.aliyuncs.com	国内访问快
腾讯云容器镜像服务	ccr.ccs.tencentyun.com	国内访问快

安装docker

如果是Windows端,开启WSL2后下载官方软件即可运行如果是Linux端,尽管文章里给了一堆命令,但现在有Dokploy了.如果是部署在国外服务器上或者自己学习使用的话,使用Dokploy就没必要操心那么多了.

Dokploy

支持Dokploy的目前有以下服务器厂商:

Hostinger
AmericanCloud
Teramont
Hetzner
DigitalOcean
Vultr
Linode
Scaleway
Google Cloud
AWS 而Dokploy目前可以在以下系统里部署:
Ubuntu 24.04 LTS
Ubuntu 23.10
Ubuntu 22.04 LTS
Ubuntu 20.04 LTS
Ubuntu 18.04 LTS
Debian 12
Debian 11
Debian 10
Fedora 40
Centos 9
Centos 8

换句话说,主流的Linux操作系统现在都支持Dokploy了

Dokploy is a stable, easy-to-use deployment solution designed to simplify the application management process. Think of Dokploy as your free self hostable alternative to platforms like Heroku, Vercel, and Netlify, leveraging the robustness of Docker and the flexibility of Traefik.

Dokploy本身就是为了简化在Linux服务器部署Docker而产生的

Dokploy utilizes Docker, so it is essential to have Docker installed on your server. If Docker is not already installed, Dokploy’s installation script will install it automatically.

甚至都不用提前安装docker,易用性可见一斑

部署

前置要求

To ensure a smooth experience with Dokploy, your server should have at least 2GB of RAM and 30GB of disk space. This specification helps to handle the resources consumed by Docker during builds and prevents system freezes.

官方推荐使用Hetzner的服务器来省钱

避免以下端口被占用:

Port 80: HTTP traffic (used by Traefik)
Port 443: HTTPS traffic (used by Traefik)
Port 3000: Dokploy web interface

我们只需要运行以下命令便可以在服务器的3000端口访问dokploy界面:

1

curl -sSL https://dokploy.com/install.sh | sh

第一次进入dokploy界面时需要我们注册管理员账户,然后就可以在面板里部署自己的docker项目了,要进一步了解的话还是去看官方文档吧.

使用镜像

获取镜像

docker pull用于从镜像仓库获取镜像:

1

docker pull [选项] [Registry地址/]仓库名[:标签]

镜像名称的标准格式如下:

1
2
3
4
5


docker.io / library / ubuntu : 24.04
────┬──── ───┬─── ──┬─── ──┬──
 │ │ │ │
Registry地址 用户名 仓库名 标签
 (可省略) (可省略)

组成部分	说明	默认值
Registry 地址	镜像仓库服务的域名或 IP 地址	`docker.io` (Docker Hub)
用户名	镜像所属的用户、组织或命名空间	`library` (官方镜像默认路径)
仓库名	镜像的具体名称	必须指定
标签 (Tag)	镜像的版本标识或分类标签	`latest`

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


## 完整格式

$ docker pull docker.io/library/ubuntu:24.04

## 省略 Registry（默认 Docker Hub）

$ docker pull library/ubuntu:24.04

## 省略 library（官方镜像）

$ docker pull ubuntu:24.04

## 省略标签（默认 latest）

$ docker pull ubuntu

## 拉取第三方镜像

$ docker pull bitnami/redis:latest

## 从其他 Registry 拉取

$ docker pull ghcr.io/username/myapp:v1.0

镜像是分层下载的,如果本地已经有相同的层(这可以通过ID来识别),那么就会跳过该层继续下载

docker pull常用参数

选项	说明	示例
–all-tags, -a	下载仓库中该镜像的所有版本标签	`docker pull -a ubuntu`
–platform	在多架构镜像中指定运行平台（如 arm64, amd64）	`docker pull --platform linux/arm64 nginx`
–quiet, -q	静默模式，只输出镜像 ID，不显示拉取进度详情	`docker pull -q nginx`

管理镜像

docker image ls

基本用法

1
2
3
4
5
6


$ docker image ls
REPOSITORY TAG IMAGE ID CREATED SIZE
redis latest 5f515359c7f8 5 days ago 183MB
nginx latest 05a60462f8ba 5 days ago 181MB
ubuntu 24.04 329ed837d508 3 days ago 78MB
ubuntu noble 329ed837d508 3 days ago 78MB

字段	说明
REPOSITORY	镜像仓库名称
TAG	镜像的标签（通常代表版本号）
IMAGE ID	镜像的唯一标识符（取 SHA-256 哈希值的前 12 位）
CREATED	镜像在构建服务器上被创建的时间
SIZE	镜像解压后在本地磁盘占用的实际空间

上面的 ubuntu:24.04 和 ubuntu:noble 拥有相同的 IMAGE ID——它们是同一个镜像的不同标签，只占用一份存储空间。

查找镜像

可以根据名字来找镜像:

1
2
3
4
5
6
7


## 列出所有 ubuntu 镜像

$ docker images ubuntu
REPOSITORY TAG IMAGE ID SIZE
ubuntu 24.04 329ed837d508 78MB
ubuntu noble 329ed837d508 78MB
ubuntu 22.04 a1b2c3d4e5f6 72MB

镜像删除

docker rmi/docker image rm

这两个命令等价,用于删除单个镜像: 使用ID删除

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


$ docker image ls
REPOSITORY TAG IMAGE ID SIZE
redis alpine 501ad78535f0 30MB
nginx latest e43d811ce2f4 142MB

## 只需输入足够区分的前几位

$ docker rmi 501
Untagged: redis:alpine
Deleted: sha256:501ad78535f0...

使用镜像名删除

1
2
3


$ docker rmi redis:alpine
Untagged: redis:alpine
Deleted: sha256:501ad78535f0...

Untagged:移除镜像标签
Deleted: 删除镜像的存储层

docker image prune

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


## 查看虚悬镜像

$ docker images -f dangling=true

$ docker image prune
# 不带参数,默认只删除悬空镜像

## 不提示确认

$ docker image prune -f

## 删除所有没有被容器使用的镜像

$ docker image prune -a

## 保留最近 24 小时的

$ docker image prune -a --filter "until=24h"

虚悬镜像 (dangling)：没有标签且未被容器引用的镜像，通常是旧版本被新版本覆盖后产生的

操作容器

启动容器

由于 Docker 容器非常轻量，实际使用中常常是随时删除和新建容器，而不是反复重启同一个容器。

基本语法

1

docker run [选项] 镜像 [命令] [参数...]

基本例子

1
2


$ docker run ubuntu:24.04 /bin/echo 'Hello world'
Hello world

基础选项

选项	说明	示例
`-d`	后台运行容器（detach）	`docker run -d nginx`
`-it`	分配交互式终端	`docker run -it ubuntu bash`
`--name`	为容器指定自定义名称	`docker run --name myapp nginx`
`--rm`	容器退出后自动删除	`docker run --rm ubuntu echo hi`

端口映射

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


## 将容器的 80 端口映射到宿主机的 8080 端口

$ docker run -d -p 8080:80 nginx

## 随机映射端口

$ docker run -d -P nginx

## 只绑定到 localhost

$ docker run -d -p 127.0.0.1:8080:80 nginx

运行容器

当你在终端运行一个程序时，有两种模式：

前台运行：程序占用当前终端，输出直接显示，关闭终端程序就停止后台运行：程序在后台执行，不占用终端，终端关闭也不影响程序 Docker 容器默认是前台运行的。使用 -d (detach) 参数可以让容器在后台运行

前台运行

1
2
3
4
5


$ docker run ubuntu:24.04 /bin/sh -c "while true; do echo hello world; sleep 1; done"
hello world
hello world
hello world
hello world

容器会把输出的结果 (STDOUT) 打印到宿主机上面。此时：

终端被占用，无法执行其他命令
按 Ctrl+C 会终止容器
关闭终端窗口，容器也会停止

后台运行

1
2


$ docker run -d ubuntu:24.04 /bin/sh -c "while true; do echo hello world; sleep 1; done"
77b2dc01fe0f3f1265df143181e7b9af5e05279a884f4776ee75350ea9d8017a

使用 -d 参数后：

容器在后台运行
返回容器的完整 ID
终端立即释放，可以继续执行其他命令
输出不会直接显示 (需要用 docker logs 查看)

终止容器

终止容器有三种方式：

方式	命令	说明
优雅停止	`docker stop`	先发 `SIGTERM`，超时后发 `SIGKILL`
强制停止	`docker kill`	直接发送 `SIGKILL` 信号
自动终止	-	容器主进程退出时自动停止

我们还可以在镜像被修改后重启容器

1
2
3
4
5
6
7


## 先停止再启动

$ docker restart 容器名

## 自定义停止超时

$ docker restart -t 30 容器名

删除容器

随着容器的创建和停止，系统中会积累大量的容器。

使用 docker rm 删除已停止的容器：

1

$ docker rm 容器名或ID

该命令与docker container rm等效

使用 docker container prune 批量删除:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


## 方式一：使用 prune 命令（推荐）

$ docker container prune

WARNING! This will remove all stopped containers.
Are you sure you want to continue? [y/N] y
Deleted Containers:
abc123...
def456...
Total reclaimed space: 150MB

## 方式二：不提示确认

$ docker container prune -f

补充部分: 镜像的文件结构

非常离谱的是,这么详细的文档偏偏没有提到这一点: 镜像内部是怎么存放文件的? 自然,镜像是分层构建存储的,但是这些构建层显然要有个地方放吧.

镜像的默认工作目录是根目录,类似于Linux的根目录,当我们需要切换存储目录或者启动某个目录下的脚本时,,可以显式指明,比如说以下的几个命令:

1
2
3
4
5
6
7


## 复制文件到指定目录

COPY package.json /app/

## 复制文件并重命名

COPY config.json /app/settings.json

如此一来,我们成功的将本地文件复制到了app文件夹中.

因此,镜像不仅仅是一个iso,我们可以把它抽象成一个文件系统,存储层堆叠在不同的目录中,可以来回切换访问.

进阶部分

dockerfile编写

概览

Dockerfile 是一个文本文件，其内包含了一条条的指令 (Instruction)，每一条指令构建一层，因此每一条指令的内容，就是描述该层应当如何构建。

Dockerfile不是脚本，而是镜像的"设计图”。这个区别决定了你如何思考每条指令的作用:

合并命令：应将 RUN apt-get update && apt-get install -y ... 写入同一个 RUN 指令中,因为它们是同一层的逻辑
优化镜像大小：最后才清理缓存、删除临时文件，让这些"瘦身"操作在同一层完成

(补充)FROM: 基础镜像

很多时候我们都需要在官方镜像的基础上进行构建,这个时候我们可以这么写:

1
2


FROM node:20-alpine AS deps
# 在这个基础上进行构建

这个AS与python中的as一样,都是为导入的镜像重新设一个名字.

事实上,如果你不写任何FROM,根本无法运行任何Linux命令

而FROM命令最厉害的地方在于,每一个FROM指令都会重新开辟一个新的文件系统,取代之前的所有内容. 因此,我们可以这么写:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 第一阶段：编译环境（命名为 builder）
FROM golang:1.21 AS builder
WORKDIR /app
COPY . .
RUN go build -o myapp main.go # 物理产生了几百 MB 的编译器和缓存

# 第二阶段：运行环境（最小化镜像）
FROM alpine:latest
WORKDIR /root/
# 物理核心：通过 --from=builder 只从 builder 阶段拷贝最终的可执行二进制文件
COPY --from=builder /app/myapp . 
CMD ["./myapp"]

这样既可以利用上一个阶段的构建内容,又不会将多余的内容打包进镜像

RUN: 执行命令

RUN 是 Dockerfile 中最常用的指令，主要用于在镜像构建阶段执行命令来修改镜像,有以下几个应用场景:

安装依赖：RUN apt-get install nginx
编译程序：RUN gcc -o app main.c
下载文件：RUN curl -O https://example.com/file.tar.gz
配置系统：RUN mkdir -p /app/data

理解 RUN 的核心是理解镜像分层：每一个 RUN 都会在当前层之上创建新的一层，这会影响镜像大小。因此，合理使用 RUN（特别是合并多个 RUN）是构建轻量级镜像的关键。

基本语法

有两种格式:

1
2


RUN <command>
RUN ["executable", "param1", "param2"]

shell格式

1

RUN apt-get update

默认通过 /bin/sh -c 执行。
可以使用环境变量、管道、重定向等 Shell 特性。

exec格式

1

RUN ["apt-get", "update"]

直接调用可执行文件，不经过 Shell。
无法使用 $VAR 环境变量替换 (除非显式调用 shell)

实战

由于每一个 RUN 指令都会新建一层镜像。为了减少镜像体积和层数，应使用 && 连接命令:

1
2
3
4
5
6
7
8


# 糟糕的写法(3层)
RUN apt-get update
RUN apt-get install -y nginx
RUN rm -rf /var/lib/apt/lists/*
# 推荐写法
RUN apt-get update && \
 apt-get install -y nginx && \
 rm -rf /var/lib/apt/lists/*

可以看到dockerfile将\用于换行,这与makefile的写法一致

COPY: 复制文件

COPY 是在构建镜像时，将构建上下文（Dockerfile 所在目录及其子目录）中的文件或目录复制到镜像内的指令。它是处理应用代码、配置文件最常用的方式,应用场景如下:

COPY . /app (应用源码)
COPY nginx.conf /etc/nginx/nginx.conf (配置文件)
COPY public /app/public(静态资源)

基本语法

1
2


COPY [选项] <源路径>... <目标路径>
COPY [选项] ["<源路径1>", "<源路径2>", ... "<目标路径>"]

复制文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


## 复制文件到指定目录

COPY package.json /app/

## 复制文件并重命名

COPY config.json /app/settings.json

## 复制多个指定文件

COPY package.json package-lock.json /app/

## 使用通配符

COPY *.json /app/
COPY src/*.js /app/src/

复制目录

1
2
3
4
5
6
7
8


## 复制整个目录的内容（不是目录本身）

COPY src/ /app/src/

# 构建上下文： 镜像内：
# src/ /app/src/
# ├── index.js → ├── index.js
# └── utils.js └── utils.js

指定路径

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# 绝对路径

COPY app.js /usr/src/app/

# 相对路径：基于 WORKDIR

WORKDIR /app
COPY package.json ./ # 复制到 /app/package.json
COPY src/ ./src/ # 复制到 /app/src/

# 如果目标目录不存在，Docker 会自动创建：

## /app/config/ 不存在也会自动创建
COPY settings.json /app/config/

dockerignore

排除不需要复制的文件,精简镜像体积

1
2
3
4
5
6
7
8


## .dockerignore

node_modules
.git
.env
*.log
Dockerfile
.dockerignore

实战

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


## ✅ 好：先复制依赖定义，再安装，最后复制代码

COPY package.json package-lock.json ./
RUN npm install
COPY . .

## ❌ 差：一次性复制所有文件，代码变更会导致重新 npm install

COPY . .
RUN npm install

详细解释一下,docker构建镜像是线性操作的,只有COPY,RUN,ADD三种命令会创建新的存储层,而每次构建时docker都会在本地存储缓存,如果下一次构建镜像时对应的命令没有变化,则会直接复用原来的缓存,不会重新构建;当docker发现COPY的文件内容有改动时,该行之后的所有命令被视为与原缓存不同,需要重新构建.

因此,如果直接写COPY . .的话,修改任何一个文件后构建镜像都要重新运行npm install;但如果把COPY . .放在后面,只会在package.json变化时重新构建.

ADD: 更高级的COPY

实践中的建议：除非你明确需要自动解压功能（比如官方基础镜像构建根文件系统），否则始终使用 COPY。原因很简单——显式优于隐式。你的 Dockerfile 在 6 个月后被接手维护时，清晰的意图会让团队少走很多弯路。

基本用法

1
2


ADD [选项] <源路径>... <目标路径>
ADD [选项] ["<源路径>", ... "<目标路径>"]

ADD 在 COPY 基础上增加了两个功能：

自动解压 tar 压缩包
支持从 URL 下载文件 (不推荐)

CMD: 容器启动命令(4/10)

在深入 CMD 的细节之前，我们需要理解一个关键问题：CMD 和 ENTRYPOINT 应该在什么时候使用？

这是 Dockerfile 使用中最常见的困惑之一。简单的答案是：

CMD：定义容器的”默认命令”。如果用户在 docker run 时提供命令，CMD 会被覆盖
ENTRYPOINT：定义容器的”入口脚本”。通常用于启动应用的某个特定部分

基本用法

CMD指令用于指定容器启动时默认执行的命令。它定义了容器的 “主进程”。

格式类型	语法示例	推荐程度	核心机制
Exec 格式	`CMD ["executable", "param1", "param2"]`	✅ 推荐	直接由内核执行，PID 为 1，可接收 `SIGTERM` 信号。
Shell 格式	`CMD command param1 param2`	⚠️ 简单场景	通过 `/bin/sh -c` 调用，无法直接接收信号，环境变量会被解析。
参数格式	`CMD ["param1", "param2"]`	⚓ 配合使用	仅作为 `ENTRYPOINT` 的默认参数传递。

exec 格式

1
2
3


CMD ["nginx", "-g", "daemon off;"]
CMD ["python", "app.py"]
CMD ["node", "server.js"]

shell格式

1
2


CMD echo "Hello World"
CMD nginx -g "daemon off;"

实际执行：会被包装为 sh -c

1
2
3
4
5
6
7


## 你写的

CMD echo $HOME

## 实际执行的

CMD ["sh", "-c", "echo $HOME"]

换句话说shell写法实际上是使用了sh的exec简写格式.

CMD命令只能写一个

多个CMD只有最后一个生效. 因为CMD的PID为1,意思是在Linux内核中它作为根进程,是独一无二的.因此CMD一旦停止,容器就关闭了.

ENTRYPOINT: 入口点(4/11)

如果说 CMD 是"容器中的默认程序"，那么 ENTRYPOINT 就是"把容器变成一个命令"。这个思维转变决定了你何时使用 ENTRYPOINT。

是什么,怎么用

ENTRYPOINT 指定容器启动时运行的入口程序。与 CMD 不同，ENTRYPOINT 定义的命令不会被 docker run 的参数覆盖，而是接收这些参数。

基本语法

1
2
3
4
5
6
7


## exec 格式（推荐）

ENTRYPOINT ["nginx", "-g", "daemon off;"]

## shell 格式（不推荐）

ENTRYPOINT nginx -g "daemon off;"

ENV: 设置环境变量

很好理解,就是设置了一个dockerfile中的变量而已.

1
2
3
4
5
6
7


## 格式一：单个变量

ENV <key> <value>

## 格式二：多个变量（推荐）

ENV <key1>=<value1> <key2>=<value2> ...

例子

1
2
3
4
5
6
7


ENV NODE_VERSION 20.10.0
ENV APP_ENV production

ENV NODE_VERSION=20.10.0 \
 APP_ENV=production \
 APP_NAME="My Application"
# 包含空格的值用双引号括起来

用法

使用 -e 或 –env 覆盖 Dockerfile 中定义的环境变量：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


## 覆盖单个变量

$ docker run -e APP_ENV=development myimage

## 覆盖多个变量

$ docker run -e APP_ENV=development -e DEBUG=true myimage

## 从环境变量文件读取

$ docker run --env-file .env myimage

运行时传入密码:

1
2
3
4
5
6
7


## ❌ 错误：密码写入镜像

ENV DB_PASSWORD=secret123

## ✅ 正确：运行时传入

## docker run -e DB_PASSWORD=xxx myimage

使用docker compose的话就没必要考虑这么多了

ARG: 构建参数

ARG仅在构建时生效,用于传递版本号之类的信息,可以出现在FROM指令之前,也能在docker build阶段传入对应的参数.换句话说,我们可以更改构建初始镜像所用的版本号.

而ENV则会被打包进入镜像,在容器运行期间永久生效,也不能出现在FROM指令之前. 基本语法

1

ARG <参数名>[=<默认值>]

用法

1
2
3
4
5
6
7
8


ARG BASE_IMAGE=python:3.12-slim
FROM ${BASE_IMAGE}

## 可以构建不同基础镜像的版本

## docker build --build-arg BASE_IMAGE=python:3.14-alpine .

...

VOLUME: 定义匿名卷

是什么,怎么用

容器存储层应该保持无状态，任何运行时数据都应该存储在volume中。

1
2
3
4
5
6
7


# 定义单个volume
FROM mysql:8.0
VOLUME /var/lib/mysql

# 定义多个volume
FROM myapp
VOLUME ["/data", "/logs", "/config"]

volume的行为

自动创建匿名卷 如果运行时未指定挂载，Docker 会自动创建匿名卷：

1
2
3
4


$ docker run mysql:8.0
$ docker volume ls
DRIVER VOLUME NAME
local a1b2c3d4e5f6... # 自动创建的匿名卷

会被命名卷覆盖

1
2
3


## 使用命名卷替代匿名卷

$ docker run -v mysql_data:/var/lib/mysql mysql:8.0

VOLUME 之后对该目录的修改会被丢弃！

1
2
3
4
5
6


FROM ubuntu
VOLUME /data

## ❌ 这个文件不会出现在镜像中！

RUN echo "hello" > /data/test.txt

原因：在构建过程中，VOLUME 指令会为该目录创建一个临时的匿名卷。后续 RUN 指令对该目录的写入实际发生在这个临时卷中，而非镜像层。当该 RUN 指令结束后，临时卷被丢弃，因此写入的内容不会保存到最终镜像中。注意：这与容器运行时创建的匿名卷是不同的——运行时创建的卷会在容器生命周期内持续存在。

正确做法

1
2
3
4
5
6
7
8
9


FROM ubuntu

## ✅ 先写入文件

RUN mkdir -p /data && echo "hello" > /data/test.txt

## 再声明 VOLUME

VOLUME /data

在compose中使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


services:
 db:
 image: postgres:16
 volumes:
 # 命名卷（推荐）

 - postgres_data:/var/lib/postgresql/data
 # Bind Mount

 - ./init.sql:/docker-entrypoint-initdb.d/init.sql

volumes:
 postgres_data: # 声明命名卷

EXPOSE: 暴露端口(4/12)

是什么,怎么用

EXPOSE 声明容器运行时提供服务的端口。这是一个文档性质的声明，告诉使用者容器会监听哪些端口。

换句话说只起一个约定作用,不通过-p的话不会起作用

基本用法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


## 声明单个端口

EXPOSE 80

## 声明多个端口

EXPOSE 80 443

## 声明 TCP 和 UDP 端口

EXPOSE 80/tcp
EXPOSE 53/udp

使用 docker run -P 时，Docker 会自动映射 EXPOSE 的端口到宿主机随机端口：

1
2
3
4
5
6


## Dockerfile
# EXPOSE 80

$ docker run -P nginx
$ docker port $(docker ps -q)
80/tcp -> 0.0.0.0:32768

实战

1
2
3
4


## Dockerfile

FROM nginx
EXPOSE 80 # 1. 声明：这个容器会在 80 端口提供服务

1
2
3


## 运行：需要 -p 才能从外部访问

$ docker run -p 8080:80 nginx # 2. 映射：宿主机 8080 → 容器 80

compose中的编写

1
2
3
4
5
6
7


services:
 web:
 build: .
 ports:
 - "8080:80" # 映射端口（类似 -p）
 expose:
 - "80" # 仅声明（类似 EXPOSE）

WORKDIR: 指定工作目录

WORKDIR 指定后续指令的工作目录。如果目录不存在，Docker 会自动创建。

基本用法

1
2
3
4
5


WORKDIR /app

RUN pwd # 输出 /app
RUN echo "hello" > world.txt # 创建 /app/world.txt
COPY . . # 复制到 /app/

1
2
3
4
5
6
7


# 相对路径

WORKDIR /a
WORKDIR b
WORKDIR c

RUN pwd # 输出 /a/b/c

实战

使用绝对命令

1
2
3
4
5
6
7


## ✅ 推荐：绝对路径，意图明确

WORKDIR /app

## ⚠️ 避免：相对路径可能造成混淆

WORKDIR app

USER: 指定当前用户

是什么,怎么用

USER 指令切换后续指令 (RUN、CMD、ENTRYPOINT) 的执行用户

1
2


USER <用户名>[:<用户组>]
USER <UID>[:<GID>]

一般是用不上这个的

HEALTHCHECK: 健康检查

是什么,怎么用

HEALTHCHECK 指令告诉 Docker 如何判断容器状态是否正常。这是保障服务高可用的重要机制。

1
2


HEALTHCHECK [选项] CMD <命令>
HEALTHCHECK NONE

基本用法

1
2
3
4
5


FROM nginx
RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*

HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
 CMD curl -fs http://localhost/ || exit 1

选项	说明	默认值
`--interval`	两次检查的间隔	30s
`--timeout`	检查命令的超时时间	30s
`--start-period`	启动缓冲期 (期间失败不计入次数)	0s
`--retries`	连续失败多少次标记为 unhealthy	3

应用启动可能需要时间 (如 Java 应用)。设置 –start-period 可以防止在启动阶段因检查失败而误判

1
2
3


## 给应用 1 分钟启动时间

HEALTHCHECK --start-period=60s CMD curl -f http://localhost/ || exit 1

LABEL: 为镜像添加元数据

是什么,怎么用

LABEL 指令以键值对的形式给镜像添加元数据。这些数据不会影响镜像的功能，但可以帮助用户理解镜像，或被自动化工具使用。

版本管理：记录版本号、构建时间、Git Commit ID
联系信息：维护者邮箱、文档地址、支持渠道
自动化工具：CI/CD 工具可以读取标签触发操作
许可证信息：声明开源协议

1

LABEL <key>=<value> <key>=<value> ...

1
2
3
4
5
6
7
8
9


# 定义单个标签
LABEL version="1.0"
LABEL description="这是一个 Web 应用服务器"

# 定义多个标签
LABEL maintainer="user@example.com" \
 version="1.2.0" \
 description="My App Description" \
 org.opencontainers.image.authors="Yeasy"

数据管理

这一章介绍如何在 Docker 内部以及容器之间管理数据，在容器中管理数据主要有以下几种方式：

数据卷
挂载主机目录
tmpfs 挂载

数据卷

容器的存储层有一个关键问题：容器删除后，数据就没了。数据卷 (Volume) 解决了这个问题，它的生命周期独立于容器。

创建和查看数据卷

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


# 创建数据卷
$ docker volume create my-vol

# 列出所有数据卷
$ docker volume ls
DRIVER VOLUME NAME
local my-vol
local postgres_data
local redis_data

# 查看数据卷详情
$ docker volume inspect my-vol
[
 {
 "CreatedAt": "2026-01-15T10:00:00Z",
 "Driver": "local",
 "Labels": {},
 "Mountpoint": "/var/lib/docker/volumes/my-vol/_data",
 "Name": "my-vol",
 "Options": {},
 "Scope": "local"
 }
]

关键字段：

Mountpoint：数据卷在宿主机上的实际存储位置
Driver：存储驱动 (默认 local，也可以用第三方驱动)

挂载数据卷

方式一：–mount：推荐

1
2
3
4


$ docker run -d \
 --name web \
 --mount source=my-vol,target=/usr/share/nginx/html \
 nginx

参数	说明
`source`	数据卷名称 (不存在会自动创建)
`target`	容器内挂载路径
`readonly`	可选，只读挂载
方式二：-v：简写

1
2
3
4


$ docker run -d \
 --name web \
 -v my-vol:/usr/share/nginx/html \
 nginx

提示：官方更推荐使用 –mount。除了语法格式可读性更好之外，最重要的行为差异发生在 绑定挂载 (Bind Mount) 时：如果挂载的宿主机源路径尚未存在，-v 会擅自将其自动创建为一个空目录；而 –mount 则会严格检查并直接报错。这能有效避免因路径拼写错误而在宿主机上留下垃圾目录（以及导致的容器访问空目录问题）。而对于本节的数据卷 (Volume) 挂载而言，两者在目标指定的卷不存在时皆会自动创建卷，产生的结果是完全一致的。

实战

数据库持久化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


## 创建数据卷

$ docker volume create postgres_data

## 启动 PostgreSQL，数据存储在数据卷中

$ docker run -d \
 --name postgres \
 -e POSTGRES_PASSWORD=secret \
 -v postgres_data:/var/lib/postgresql/data \
 postgres:16

## 即使删除容器，数据仍然保留

$ docker rm -f postgres

## 重新启动，数据还在

$ docker run -d \
 --name postgres \
 -e POSTGRES_PASSWORD=secret \
 -v postgres_data:/var/lib/postgresql/data \
 postgres:16

多容器共享数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


## 创建共享数据卷

$ docker volume create shared-data

## 容器 A 写入数据

$ docker run -d --name writer \
 -v shared-data:/data \
 alpine sh -c "while true; do date >> /data/log.txt; sleep 5; done"

## 容器 B 读取数据

$ docker run --rm \
 -v shared-data:/data \
 alpine cat /data/log.txt

配置文件持久化

1
2
3
4
5
6
7


## 将 nginx 配置存储在数据卷中

$ docker run -d \
 -v nginx-config:/etc/nginx/conf.d \
 -v nginx-logs:/var/log/nginx \
 -p 80:80 \
 nginx

挂载主机目录

绑定挂载

Bind Mount (绑定挂载) 将 Docker daemon 所在主机上的目录或文件直接挂载到容器中。容器可以读写这台主机上的文件系统。 Bind Mount vs Volume

特性 Bind Mount (绑定挂载) Volume (数据卷)

数据位置 宿主机任意路径 Docker 管理的特定目录 (/var/lib/docker/volumes/)

路径指定 必须是绝对路径 (如 /opt/app/data) 卷名 (如 my-vol)，隐式管理物理路径

可移植性 低。依赖宿主机特定的文件目录结构高。不依赖物理路径，易于在不同环境迁移

性能依赖宿主机文件系统原生性能绕过 Storage Driver 层，具备原生 I/O 性能

适用场景 开发环境同步代码、挂载宿主机配置文件生产环境数据库持久化、日志存储、多容器共享

备份与管理 手动定位宿主机路径进行备份使用 docker volume 命令管理，备份需挂载容器操作

隔离性 宿主机进程可轻易修改，安全性较低由 Docker 隔离，减少了被宿主机其他进程误删的风险

基本语法

方案 A：使用 --mount（推荐方式）

1
2
3
4


$ docker run -d \
 --name web-bind \
 --mount type=bind,source=/宿主机路径,target=/容器路径 \
 nginx

方案 B：使用 -v（简写方式）

1
2
3
4


$ docker run -d \
 --name web-v \
 -v /宿主机路径:/容器路径 \
 nginx

可以看到,这里的语法与之前的volume挂载基本相同

网络配置

配置DNS

Docker 容器的 DNS 配置有两种情况：

默认 Bridge 网络：继承宿主机的 DNS 配置 (/etc/resolv.conf)。
自定义网络(推荐)：使用 Docker 嵌入式 DNS 服务器 (Embedded DNS)，支持通过 容器名 进行服务发现。

使用自定义网络

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


## 1. 创建自定义网络

$ docker network create mynet

## 2. 启动容器 web 并加入网络

$ docker run -d --name web --network mynet nginx

## 3. 启动容器 client 并尝试 ping web

$ docker run -it --rm --network mynet alpine ping web
PING web (172.18.0.2): 56 data bytes
64 bytes from 172.18.0.2: seq=0 ttl=64 time=0.074 ms

端口映射

容器的网络访问规则如下：

容器之间：可以通过 IP 或容器名 (自定义网络) 互通。
宿主机访问容器：可以通过容器 IP 访问。
外部网络访问容器：❌ 默认无法直接访问。

为了让外部 (如你的浏览器、其他局域网机器) 访问容器内的服务，我们需要将容器的端口映射到宿主机的端口。

基本用法

1
2
3


## 将宿主机的 8080 端口映射到容器的 80 端口

$ docker run -d -p 8080:80 nginx:alpine

此时访问 http://localhost:8080 即可看到 Nginx 页面。

格式	含义	示例
ip:hostPort:containerPort	绑定指定 IP 的特定端口	`-p 127.0.0.1:8080:80` (仅允许本机访问)
ip::containerPort	绑定指定 IP 的随机端口	`-p 127.0.0.1::80`
hostPort:containerPort	绑定所有网卡 IP (`0.0.0.0`) 的特定端口	`-p 8080:80` (最常用格式)
containerPort	绑定所有网卡 IP 的随机端口	`-p 80`

随机映射

如果不关心宿主机使用哪个端口，可以使用随机映射。使用 -P (大写) 参数，Docker 会把 Dockerfile 中 EXPOSE 指令暴露的所有端口发布到宿主机的随机高位端口。具体落在哪个端口，取决于宿主机当前可用的临时端口范围。

1
2
3
4
5
6


docker run -d -P nginx

docker ps
CONTAINER ID PORTS
abc123456 0.0.0.0:49153->80/tcp
# 此时 Nginx 被映射到了宿主机的一个随机高位端口49153

实战

默认情况下，-p 8080:80 会监听 0.0.0.0:8080，这意味着任何人只要能连接你的宿主机 IP，就能访问该服务。如果不希望对外暴露 (例如数据库服务)，应绑定到 127.0.0.1：

1
2
3


## 仅允许本机访问

$ docker run -d -p 127.0.0.1:3306:3306 mysql

网络隔离

不同网络之间默认隔离，容器只能与同一网络中的容器直接通信：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


## 创建两个网络

$ docker network create frontend
$ docker network create backend

## 容器 A 在 frontend

$ docker run -d --name web --network frontend nginx

## 容器 B 在 backend

$ docker run -d --name db --network backend postgres

## web 无法直接访问 db（不同网络）

$ docker exec web ping db
ping: db: Name or service not known

Docker Compose

概览

在学习 Compose 之前，笔者想强调它的真正价值。假设你正在开发一个微服务应用——前端、后端、数据库三个服务。如果你用 Docker 容器分别运行它们，你会遇到这些问题：

启动顺序：需要先启数据库，再启后端，最后启前端
网络连接：三个容器需要能彼此通信
卷挂载：本地代码需要映射到容器内
环境变量：每个服务的配置需要逐个设置

使用 docker run 逐个启动的话，需要记住 3 条复杂的命令。而 Docker Compose 的核心价值就是用一个 YAML 文件来定义整个应用，然后一条命令 docker compose up 启动所有服务。这是 Compose 被广泛采用的原因——它极大地简化了本地开发和测试的复杂性。

Compose 项目早期由 Python 编写，称为 Docker Compose V1,现在的 Docker Compose V2 是一个 Go 语言编写的 Docker CLI 插件。Docker Desktop 默认包含它

关键定义

服务 (service)：一个应用容器，实际上可以运行多个相同镜像的实例。
项目 (project)：由一组关联的应用容器组成的一个完整业务单元。

可见，一个项目可以由多个服务 (容器) 关联而成，Compose 面向项目进行管理。

补充: compose命令行

基本使用格式

1

docker compose [-f=<arg>...] [options] [COMMAND] [ARGS...]

参数说明

-f, --file FILE: 指定使用的 Compose 模板文件。默认会自动识别 compose.yaml (也兼容 docker-compose.yml 等)，并且可以多次指定。
-p, --project-name NAME: 指定项目名称，默认将使用所在目录名称作为项目名。
--verbose: 输出更多调试信息。
-v, --version: 打印版本并退出。

事实上,想要更好的理解docker compose命令,需要和没有compose的docker命令进行比较:

构建项目

docker compose build: 根据当前目录的compose.yml文件进行构建,如果没有用-f指定文件名字的话,会在当前目录中按以下顺序检索，匹配到第一个即停止查找
- compose.yaml（官方推荐的首选名称）
- compose.yml
- docker-compose.yaml
- docker-compose.yml（历史最常用的名称，现降级为备选）
docker build: 根据当前目录的dockerfile构建镜像 更多的相同点

都会在目标文件变更时才重新构建镜像

自然,它完全可以被且已经被docker compose up取代

启动项目

docker run: 根据镜像名字启动容器,若依赖的镜像尚未构建且可以从远端拉取时,则先拉取该镜像后再启动容器,
docker compose up: 根据compose.yml启动项目,若依赖的services(服务)有一些或者全部没有对应的镜像则会先构建再启动项目.

更多的相同点

都支持使用-d参数来后台运行

事实上,docker compose up的特性比上面所说的要复杂得多,我们可以compose.yml中预先在build关键字中指定了对应的构建目录和dockerfile,则每次运行docker compose up时可以加上--build参数,来实现在对应的构建目录有更改时自动构建镜像后运行.

因此,如果容器不报错的话我们可以只使用docker compose up命令完成实时的构建和项目运行.

停止和删除容器

docker compose stop: 停止所有服务,保留容器和网络,当然也保留数据卷
docker compose down: 停止所有服务后删除容器和网络,默认保留数据卷,除非加上-v参数,这会删除所有匿名卷和命名卷,但保留绑定挂载文件
docker stop: 正常停止容器,不会删除容器
docker kill: 强制停止容器,不会删除容器
docker rm 容器名: 删除某个容器
docker rmi 镜像名: docker remove image的缩写,删除某个镜像
docker container prune: 删除虚悬容器
docker image prune: 删除虚悬镜像

docker compose logs: 日志查看

基本格式

1

docker compose logs [options] [SERVICE...]

参数

--tail=50: 指定对应的最新日志行数 tail参数的默认值为all,输出所有服务或者在指定服务名字时输出该服务的所有日志.

如果构建报错,都需要使用该命令来查看具体的构建问题.

进阶用法: 多compose文件编排

官方文档前面所说的docker compose up还可以通过使用多个-f参数,实现多文件的覆盖,从而将生产环境和部署环境彻底隔离开来,具体用法如下:

执行命令

1

docker compose -f compose.yml -f compose.prod.yml up -d

compose.yml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


# 核心基础配置，定义通用架构
services:
 web:
 image: nginx:alpine
 # 列表类字段（如 ports）在多文件模式下会执行“取并集”操作
 ports:
 - "8080:80"
 # 映射类字段（如 environment）若键名重复，后续文件将覆盖此处的值
 environment:
 - NODE_ENV=development
 - DEBUG=true
 # 默认重启策略
 restart: "no"

 db:
 image: postgres:15-alpine
 volumes:
 - db_data:/var/lib/postgresql/data

volumes:
 db_data:

compose.prod.yml

 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


# 生产环境专用覆盖，修改性能参数与安全性
services:
 web:
 # 覆盖：将基础镜像替换为稳定版标签
 image: nginx:stable-alpine
 # 覆盖：修改同名环境变量，关闭调试模式
 environment:
 - NODE_ENV=production
 - DEBUG=false
 # 合并：保留基础文件的 8080 端口，并额外增加 443 端口映射
 ports:
 - "443:443"
 # 覆盖：生产环境要求容器崩溃后自动重启
 restart: always
 # 新增：生产环境特有的部署约束
 deploy:
 resources:
 limits:
 cpus: '0.5'
 memory: 512M

 db:
 # 扩展：仅在生产环境中对数据库启用加密连接强制要求
 command: ["postgres", "-c", "ssl=on"]

# 注意：volumes 和 networks 的合并同样遵循并集原则

补充: compose编写

build: 指定dockerfile路径

指定 Dockerfile 所在文件夹的路径 (可以是绝对路径，或者相对 Compose 文件的路径)。Compose 将会利用它自动构建这个镜像，然后使用这个镜像.

Dockerfile 中设置的选项 (例如：CMD、EXPOSE、VOLUME、ENV 等) 将会自动被获取，无需在 Compose 文件中重复设置。

1
2
3
4
5
6
7


services:
 webapp:
 build:
 # 指定dockerfile路径
 context: ./dir
 # 指定dockerfile名字
 dockerfile: Dockerfile-alternate 

进阶用法

使用arg参数指定构建镜像时的变量:

1
2
3
4
5
6
7


 frontend:
 build:
 context: .
 dockerfile: frontend/Dockerfile
 args:
 - VITE_API_URL=https://api.${DOMAIN?Variable not set}
 - NODE_ENV=production

image: 指定镜像

指定该服务使用的镜像名称或ID,如果该镜像本地不存在,则会去远程仓库拉取该镜像

进阶用法

image可以与build进行配合,指定build生成的镜像名字:

1
2
3
4
5
6
7
8
9


services:
 frontend:
 image: '${DOCKER_IMAGE_FRONTEND?Variable not set}:${TAG-latest}'
 build:
 context: .
 dockerfile: frontend/Dockerfile
 args:
 - VITE_API_URL=https://api.${DOMAIN?Variable not set}
 - NODE_ENV=production

${DOCKER_IMAGE_FRONTEND?Variable not set}: compose语法${VAR?ErrorMessage},若VAR为定义或为空,则compose会报错并停止运行,在终端输出该调试信息
TAG-latest: compose语法${VAR-DefaultValue},VAR变量未定义时提供默认值

如果compose.yml所在目录的.env文件中有如下定义:

DOCKER_IMAGE_FRONTEND = frontend
TAG = 1.0

而该项目的名字为web,则这个镜像在docker中的最终名字为web-frontend:1.0.

volumes: 指定挂载的数据卷

数据卷所挂载路径设置。可以设置为宿主机路径 (HOST:CONTAINER)(即绑定挂载) 或者数据卷名称 (VOLUME:CONTAINER)，并且可以设置访问模式 (HOST:CONTAINER:ro)。

用法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


volumes:
 - /var/lib/mysql
 - cache/:/tmp/cache
 - ~/configs:/etc/configs/:ro

# 如果路径为数据卷名称，必须在文件中配置数据卷。
services:
 my_src:
 image: mysql:8.0
 volumes:
 - mysql_data:/var/lib/mysql

volumes:
 mysql_data:

env_file与environment: 环境变量

env_file: 指定环境变量文件路径。
- 如果通过 docker compose -f FILE 方式来指定 Compose 模板文件，则 env_file 中变量的路径会基于模板文件路径。
- 如果有变量名称与 environment 指令冲突，则按照惯例，以后者为准。

该环境文件需要严格符合.env格式:

1
2
3
4


## common.env: Set development environment

PROG_ENV=development
# 等号两边无空格

即使没有使用env_file关键字,compose依然会自动读取对应目录的.env文件.

environment: 设置服务的环境变量,如果只给定名称,会自动读取环境变量，可以用来防止泄露不必要的数据.

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


services:

 db:
 image: postgres:18
 env_file:
 - .env
 environment:
 - PGDATA=/var/lib/postgresql/data/pgdata
 - POSTGRES_PASSWORD=${POSTGRES_PASSWORD?Variable not set}
 - POSTGRES_USER=${POSTGRES_USER?Variable not set}
 - POSTGRES_DB=${POSTGRES_DB?Variable not set}

command: 覆盖容器启动后默认执行的命令

command: bash scripts/prestart.sh

healthcheck: 健康检查

通过命令检查容器是否健康运行。

1
2
3
4
5


healthcheck:
 test: ["CMD", "curl", "-f", "http://localhost:8000/api/v1/utils/health-check/"]
 interval: 10s
 timeout: 5s
 retries: 5

test: 检查时执行的命令
interval: 执行间隔
timeout: 超过该时间限制仍未收到响应则视为这次检查失败
retries: 第一次检查失败后的总尝试次数,若5次都失败则将该服务标记未不健康(unhealthy).

该关键字通常与depends_on关键字搭配使用.

depends_on

先看这个例子:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


services:
 web:
 build: .
 depends_on:
 - db
 - redis

 redis:
 image: redis

 db:
 image: postgres

web需要在redis和db两个服务都启动后才可以启动.

也就是说depends_on规定了容器启动的先后顺序,保证需要其他服务作为依赖的容器滞后启动.

进阶用法: 搭配healthcheck

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


services:
 db:
 image: postgres:18
 restart: always
 healthcheck:
 test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
 interval: 10s
 retries: 5
 start_period: 30s
 timeout: 10s
 prestart:
 depends_on:
 db:
 condition: service_healthy
 restart: true 
 backend:
 depends_on:
 db:
 condition: service_healthy
 restart: true
 prestart:
 condition: service_completed_successfully

关键字解析

condition: 要求相关依赖服务必须达到的具体状态
restart: 对应服务重启时backend也必须重启
service_healthy: 要求对应服务通过了健康检查,状态变为healthy
service_completed_successfully: 用于一次性服务中,要求对应服务运行后正常退出

labels

设置服务标签,供第三方工具识别

例如我们可以给后端加上traefik标签:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


labels:
 - traefik.enable=true
 - traefik.docker.network=traefik-public
 - traefik.constraint-label=traefik-public

 - traefik.http.services.${STACK_NAME?Variable not set}-backend.loadbalancer.server.port=8000

 - traefik.http.routers.${STACK_NAME?Variable not set}-backend-http.rule=Host(`api.${DOMAIN?Variable not set}`)
 - traefik.http.routers.${STACK_NAME?Variable not set}-backend-http.entrypoints=http

 - traefik.http.routers.${STACK_NAME?Variable not set}-backend-https.rule=Host(`api.${DOMAIN?Variable not set}`)
 - traefik.http.routers.${STACK_NAME?Variable not set}-backend-https.entrypoints=https
 - traefik.http.routers.${STACK_NAME?Variable not set}-backend-https.tls=true
 - traefik.http.routers.${STACK_NAME?Variable not set}-backend-https.tls.certresolver=le

 # Enable redirection for HTTP and HTTPS
 - traefik.http.routers.${STACK_NAME?Variable not set}-backend-http.middlewares=https-redirect

networks

配置容器连接的网络,若不声明,所有服务都加入默认的桥接网络,彼此可见

写法如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


services:

 some-service:
 networks:
 - some-network
 - other-network

networks:
 some-network:
 other-network:

expose: 暴露端口

暴露端口,但不映射到宿主机仅可以指定docker内部端口为参数:

1
2
3


expose:
 - "3000"
 - "8000"

docker中装载操作系统

RESTful Web APIs

补充: 什么是RESTful Web API

非常令人震惊的是,这本书并没有谈到这一名词的具体概念和历史背景…因此需要在这里做一点补充

非常优秀的中文博客解析

只看上面的文章就够了,我再加上一点历史背景解析

历史背景

根据« RESTful Web APIs Patterns and Practices Cookbook »总结

在www(万维网)的概念于1993年左右开始盛行时,并没有一个合适的规范来约束用户端和服务器之间的通信.

于是,web技术大牛Roy T. Fielding在1998年的微软演讲提出了Representational State Transfer(REST)的初步构想,并在两年后的论文(“Architectural Styles and the Design of Network-based Software Architectures”)中完整的介绍了REST,总结一下大致意思就是:

REST provides a set of architectural constraints that, when applied as a whole, emphasizes scalability of component interactions, generality of interfaces, independent deployment of components, and intermediary components to reduce interaction latency, enforce security, and encapsulate legacy systems.

看不懂没关系,我们只需要知道Rest的主要准则如下:

约束名称	核心要求	违背后的后果
客户机-服务器 (Client-Server)	前后端分离，职责解耦。	无法独立演进，扩展性受阻。
无状态 (Stateless)	每个请求必须包含处理所需的全部信息，服务器不保存会话上下文。	导致服务器无法水平扩展，容错性降低。
可缓存 (Cacheable)	响应必须定义自身是否可缓存。	增加网络延迟，浪费带宽和服务器资源。
统一接口 (Uniform Interface)	包含资源标识、通过表述操纵资源、自描述消息、HATEOAS。	最常被忽视的一项。不满足此项的通常只是“带 HTTP 的 RPC”。
分层系统 (Layered System)	客户端无法感知直接连接的是服务器还是中间件（代理、缓存）。	破坏安全性与负载均衡的透明度。
按需代码 (Code on Demand)	（可选）允许服务器向客户端发送可执行代码（如 JS）。	增加客户端复杂度和安全风险。

如果你的Web架构设计和API请求符合这些原则,则可以被称为Restful Web和Restful Web API.(rest-ful,意思大致为rest风格)

Deep Learning from Scratch

pdf链接如前所说,阅读« Transformers快速入门 »的前提是要搞懂神经网络是什么,于是我辗转找到了这本享有盛名的书,希望能够彻底理解神经网络的概念

On Java 8

中文翻译版链接

Understanding The Linux Kernel(深入理解Linux内核)

操作系统教材笔记

Sat, 14 Mar 2026 08:00:00 +0000

Outline

ch1 概述
ch2 硬件环境
ch3 操作系统结构
ch4 进程基础
ch5 线程
ch6 CPU调度
ch7 进程同步
ch8 死锁
ch9 内存管理基础
ch10 虚拟内存管理
ch11 文件系统
ch12 设备管理
ch13 磁盘结构

按照课程大纲来看,只需要学到教材的第十三章就可以了

参考教材:操作系统概念(第九版) 事实上,看原文会很累,废话太多,真东西太少,而且比较混乱,我只好移步中文翻译,节省点时间

archive1

 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
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171


# ch1&&ch2
操作系统:运行在计算机上的程序(称为内核(kernel))

## 实时操作系统 (RTOS) 与 分时操作系统 (TSOS)

* **分时系统 (Time-Sharing):** 追求**资源利用率**与**公平性**。通过将 CPU 时间划分为极小的“时间片”，轮流分配给多个用户或任务，营造“独占计算机”的错觉。其关键指标是**平均响应时间**。
* **实时系统 (Real-Time):** 追求**确定性 (Determinism)** 与**可预测性**。任务必须在严格定义的截止时间内完成。其关键指标是**最坏情况下的响应延迟**。



# ch3:进程
进程:操作相关资源执行某一命令的活动实体

### 进程控制块(Process Control Block,PCB)
进程可以用PCB来表示,它包含许多与某个特定进程相关的信息:
- 进程状态: new,running,waiting,terminated
- 程序计数器(program counter,PC): 进程要执行的下个指令的地址
- 寄存器(CPU register)
- CPU调度信息
### 进程调度
#### 调度序列
进程在进入系统时,会被加入到一个作业队列(job queue)中.
最初,新进程会进入就绪队列(ready queue),直到被选中执行,之后可能发生以下事件:
- 进程创建了一个新的子进程,并等待子进程终止
- 进程由于中断被强制返回就绪队列
- 发出使用某个设备的请求,进入设备队列

#### 调度类型

* **高级调度 (High-Level Scheduling)**
 * 也称为**作业调度**或**宏观调度**。
 * **核心逻辑**：负责从后备队列中挑选作业进入内存，为其创建进程并分配必要的资源。
 * **时间尺度**：通常是**分钟、小时或天**。


* **中级调度 (Intermediate-Level Scheduling)**
 * 涉及进程在**内、外存间的交换**（Swapping）。
 * **资源管理维度**：从存储器资源管理的角度来看，把进程部分或全部**换出到外存**上，可为当前运行进程的执行提供所需内存空间；反之，将当前进程所需部分**换入到内存**。
 * **物理约束**：指令和数据必须在内存里才能被处理机直接访问。


* **低级调度 (Low-Level Scheduling)**
 * 也称**微观调度**或**进程调度**。
 * **资源分配维度**：从处理机资源分配角度来看，处理机需要经常选择**就绪进程或线程**进入运行状态。
 * **时间尺度**：通常是**毫秒级**的。
 * **实现要求**：由于低级调度算法使用频繁，要求在实现时做到**高效**。
### 进程运行
#### 进程创建
当进程创建新进程时,有两种情况:
1. 父进程和子进程并发执行
2. 父进程等待子进程执行完毕

新进程的地址空间有两种可能:
1. 子进程与父进程有同样的程序和数据
2. 子进程加载的是另一个新程序

#### 进程终止
>Process executes last statement and asks the operating system to delete it (exit).

Parent may terminate execution of children processes (abort).
- Child has exceeded allocated resources.
- Task assigned to child is no longer required.
- Parent is exiting.
 - Operating system does not allow child to continue if its parent terminates,which is called as **Cascading termination**.

- [chrome多线程架构](https://developer.chrome.com/blog/inside-browser-part1?hl=zh-cn)

### 进程间通信(InterProcess Communication,IPC)
与其他进程共享数据的进程为协作进程,协作进程需要有一种进程间通信的机制,允许进程之间交换数据,有两种基本模型:
1. 共享内存模型: 建立起一块供协作进程共享的内存区域.
2. 消息传递模型: 通过消息队列来处理. 

#### 共享内存模型
一种方法是通过一个缓冲区供producer存放信息和consumer提取信息,这里的producer和consumer是相对的,协作进程可以同时扮演这两个角色
#### 消息传递系统(待补充)

# ch4:线程
### 概述
线程:cpu使用的基本单元,包括线程ID,程序计数器,寄存器组和堆栈,与同一进程的其他线程共享代码段,数据段和其他操作系统资源.
- 如果一个进程有多个线程,那么就能同时执行多个任务

### 多核编程
对于单核系统,并发仅意味着线程随着时间推移交错执行,因为内核在某一时刻只能执行单个线程;但对于多核系统,并发可以让线程并行运行

#### 并行类型
**数据并行**: 将数据分布于多个核上,在每个核上执行相同操作
**任务并行**: 不同核上的每个线程都执行一个单独的操作,可以操作相同的,也可以操作不同的数据

### 多线程模型
用户层的用户线程需要内核层的内核线程来支持和管理,有三种常见的关系模型
#### 多对一模型
映射多个用户级线程到一个内核线程,显然这无法利用多核操作系统
#### 一对一模型
一个用户线程对应一个内核线程,唯一缺点是创建一个用户线程就要创 建一个相应的内核线程,会影响应用程序的性能,故需要限制某一时刻下可供使用的线程数量,Linux和Windows是采用这一模型的代表
#### 多对多模型
该模型可以将多个用户线程映射到多个内核线程中
### 线程库
线程库为程序员提供创建和管理线程的API,有两种方法实现线程库:
1. 在用户层实现一个无内核支持的库,手写寄存器调用之类的操作
2. 在内核层实现一个库,创建线程时会发生系统调用
# ch5:CPU如何调度进程
### 调度算法
#### 先到先服务(First Come First Served ,FCFS)
当一个进程进入准备队列时,会被链接到队列尾部.
**缺点**: 平均等待事件很长,一旦CPU分配给了一个进程,进程就会一直运行直到CPU释放,不适用于分时系统
#### 最短作业优先调度(Shortest Job First ,SJF)
当CPU空闲时,会分配给执行时间最短的进程.
**缺点**: 很难判断新进程的具体执行时间,只能通过估计来处理
可分为抢占的和非抢占的,对于抢占SJF算法来说,如果当前执行的进程所需剩余执行时间比新进程长,就会被抢占.
#### 优先级调度(priority scheduling)
通过对进程标识优先级,保证优先级最高的进程先执行,同样可以分为抢占的和非抢占的.
**缺点**: 无穷阻塞,即低优先级进程可能永远无法执行,解决方法是老化(aging),即根据等待时间提高等待进程的优先级
#### 轮转调度(Round Robin,RR)
这个算法是专门为分时系统设计的,结合了FCFS调度和抢占的概念:
将一个较小时间单元(如10-100ms)定义为时间片,CPU调度程序为每个进程分配不超过一个时间片的占用时间,当一个进程占用时间超过一个时间片时,将会被抢占,并被加到队列尾部.

关键在于要根据进程切换的时间花费来设计时间片大小,从而保证进程切换不会过度拖延平均的进程运行时间.
#### 多级队列调度(multilevel queue)
根据进程的类型,大小,将准备队列分成具有优先级别划分的多个单独队列,每个队列使用独特的调度算法.
#### 多级反馈队列调度(multilevel feedback queue)
在多级队列调度中,进程进入系统时会被永久分配到某个队列.
但现在讨论的反馈队列调度算法允许进程在队列之间迁移,将等待过长的进程放入高优先级队列,将用时过长的进程放入低优先级队列.
- 是最通用,但也是最复杂的算法

### 线程调度(待补充)

### 多处理器调度
当操作系统有多个核即有多个CPU时,进程的调度会变得更加复杂,有两种方法,一种是让一个处理器负责处理所有的调度决定,I/O处理核其他系统活动,而其他的处理器只执行用户代码.这被称为**非对称多处理**.因为只有一个处理器能够访问系统数据,减少了数据共享的负担.
另一种方法是使用对称多处理(Symmetric MultiProcessing,SMP),每个处理器自我调度,可以使用一个共享的准备队列,也可以每个处理器单独使用一个准备队列.
几乎所有的现代操作系统都采用这一方案.

#### 处理器亲和性(processor affinity)
由于将一个进程从一个处理器转移到另一个处理器需要在处理器之间迁移缓存,代价过高,因此需要让一个进程一直运行在同一个处理器上,这被称为**处理器亲和性**.

#### 负载平衡(load balance)
对于共享队列的多处理器操作系统,由于处理器需要一直从队列中取得最新的进程,故没有处理器会保持空闲.
但对于具有单独准备队列的多处理器操作系统,需要决定每个处理器的负载分配,避免有处理器的负载太高或者太低.
有两种方法:
1. 推迁移(push migration): 超载处理器将进程push到空闲处理器
2. 拉迁移(pull migration): 空闲处理器从超载处理器pull进程.

这两种方法经常被同时使用,但因为发生了进程在处理器之间的迁移,会抵消**处理器亲和性**带来的好处.

#### 多核处理器
在多核处理器中应用多线程有两种方法:
1. 粗粒度(coarse-grained): 线程一直在处理器上执行,直到突然遇到长时间的中断(这里的中断仅仅是指处理器停止运行,而非通常意义的主动性中断),这时处理器会切换执行另一个线程.
2. 细粒度(fine-grained): 通过精细化线程的运行逻辑,减小线程的切换成本

### 实时操作系统的CPU调度(过)




# ch6:同步
### 临界区问题
假设某个系统有n个进程,每个进程有一段代码,称为**临界区**(critical section).当一个进程在临界区执行时,其他进程不允许在各自的临界区内执行,因为这个正在执行的进程有可能正在修改公共资源,不能被打扰.
临界区问题的具体情景如下:
在进入临界区前,每个进程需要进行访问申请,实现访问申请的代码段称为**进入区**;在临界区执行完后有**退出区**,其他代码为**剩余区**.
因此,我们需要实现以下三个要求:
1. 互斥: 保证某一时刻只有一个进程能够在临界区执行
2. 提升: 如果没有进程在临界区执行,那么只有不处于剩余区的进程可以选择是否进入临界区.
3. 有限等待: 如果有一个进程位于进入区,那么其他进程允许进入临界区的次数有一个上限值,从而保证该进程可以进入临界区


### 基于软件的临界区问题解决方案: Peterson
不妨假设有两个交替运行的进程P0和P1,这两个进程共享以下数据项:

```java
int turn;
boolean flag[2];
//turn表示允许让哪个进程进入临界区,flag表示哪个进程位于进入区.

archive2

 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
95
96
97


那么,只有当turn为i且flag[i]=1的时候这个进程才能真正执行.
现在我们需要证明这个解决方案是有效的,即证明前文提及的三点.
1. 当flag[0]和flag[1]都为1时,由于turn只能有一个值,故只有一个进程可以在临界区执行
2. 当进程P0在临界区执行完毕后,它进入退出区,并切换turn为1.此时flag[0]==0,而如果P1在进入区的话,那么flag[1]==1,而turn为1,故P1进入临界区执行,执行完后再将turn置为0.从而实现循环运行.

### 基于硬件的解决方案(待补充)

### 

# ch7:死锁(deadlock)(3/22)
- 从这里开始使用中英文版交杂的形式

当某个进程申请资源时,若该资源当前不可用,则进程进入等待队列,但如果这个资源一直被其他进程占有,这个进程将一直位于待定状态,这被称为**死锁**.
### System Model
进程使用资源的全过程:
1. 申请: 进程请求资源,如果资源暂时无法获取,那么进入等待队列
2. 使用: 进程使用资源
3. 释放: 进程释放资源

- 那么很显然的是,只有我们能够保证进程在使用后会释放资源,就不会出现死锁问题,除非新进程不停的大量出现

### 死锁出现的必要条件
1. 互斥: 某个资源同时刻只能被一个进程使用
2. 占有和等待: 一个进程应占有至少一个资源,并等待另一个被其他进程占有的资源
3. 不允许抢占: 资源只能在进程完成任务后自动释放
4. 循环队列: A set {P 0 , P 1 , ..., P n } of waiting processes must exist such that P 0 is waiting for a resource held by P 1 , P 1 is waiting for a resource held by P 2 , ..., P n−1 is waiting for a resource held by P n , and P n is waiting for a resource held by P 0 .

只有着四种条件都满足时才会出现死锁,这显然是一个非常极端的情况
#### Resource-Allocation Graph(过)
光画图的话我想考试不会考的
### Methods for Handling Deadlocks(处理死锁问题)
Generally speaking, we can deal with the deadlock problem in one of three ways:
• We can use a protocol to prevent or avoid deadlocks, ensuring that the system will never enter a deadlocked state.
• We can allow the system to enter a deadlocked state, detect it, and recover.
• We can ignore the problem altogether and pretend that deadlocks never occur in the system.
由于大多数操作系统采用第三种方式也就是忽视死锁问题,因此开发应用程序时需要开发人员自己来处理死锁问题,有三种常见的操作:
1. 死锁预防(deadlock prevention): 确保死锁发生的必要条件不全部成立
2. 死锁避免(deadlock avoidance): 为操作系统提供相关进程信息来合理调度资源
3. 死锁恢复: 检测是否发生了死锁和如何从死锁中恢复

### Deadlock Prevention
我们通过讨论发生死锁的4个条件来谈谈如何预防死锁:
1. **互斥**: 使用可共享的资源,如只读文件等
2. **持有并等待**: 当进程申请一个资源时,它不能占有其他资源,我们有两种方法:
 1. 进程需要在执行前申请所需的所有资源
 2. 进程仅在没有资源时才可以申请资源,或者在申请更多资源之前需要释放占用的资源
 3. 但这两种方法会导致资源利用率低,某个进程进入**饥饿**状态等问题
3. 无抢占: 如果一个进程申请一个被占用的资源时,他目前占用的资源都可以被抢占
4. 循环等待: 对所有的资源类型进行排序,确保每个进程按顺序申请资源

#### 循环等待的解决方法详解

### Deadlock Avoidance
#### Safe State
>A state is safe if the system can allocate resources to each process (up to its maximum) in some order and still avoid a deadlock. More formally, a system is in a **safe state** only if there exists a **safe sequence**. 
#### Banker’s Algorithm

### Deadlock Detection
### Recovery from Deadlock
可以使用两种方法:
1. 进程终止: 可以终止所有死锁进程或者一次终止一个进程直到消除死锁
2. 资源抢占: 抢占死锁进程占用的资源直到消除死锁
# ch8: Main Memory
本章主要讨论内存管理的各种方法
## Background
### Basic Hardware
CPU可以直接访问的存储器是内存和寄存器,但由于内存的执行时间一般超过一个时钟周期,故需要在CPU和内存之间增加一个高速缓存(cache)

为了保证不同进程之间不会相互影响,我们可以用下面所述的一种简单方法来处理:
1. 每个进程都应该有一个单独的内存空间,因此我们需要确定单一进程可以访问的地址范围
2. 我们使用两个寄存器: 基地址寄存器(base register)-含有最小的合法物理内存地址,地址范围寄存器(limit register)-指定地址的范围大小.
 1. 例如: 基地址为10000,地址范围为1200,则该进程可以合法访问从10000到11200的所有地址
3. 当然,如果进程本身可以修改这两个寄存器,那就没有意义了,因此,只有操作系统可以加载并修改这两个寄存器

### Address Binding
用户程序执行时,操作系统需要将指令和数据绑定到存储器里的对应地址上(不然怎么执行),有三种常见的绑定时机:
1. compile time: 编译时就将进程绑定在一个固定地址上,非常省心,但缺点是当地址变化时,就需要重新编译代码.
2. load time: 加载时用相对地址来绑定进程,当地址变化时,只需要重新加载程序代码就可以了
3. runtime time: 如果进程在执行时会跳跃地址,那么我们就只能在进程执行的时候再绑定地址,这也是现代操作系统采用的方法
### Logical Versus Physical Address Space
当我们采用runtime time方案来绑定进程时,将程序生成的地址称为**虚拟地址**(也称为逻辑地址),虚拟地址对应的实际地址称为**物理地址**.

将虚拟地址映射到物理地址的硬件设备是Memery-Management Unit(MMU,内存管理单元),在这里我们先介绍一种简单的映射方案:
- 将虚拟地址加上重定位寄存器(relocation register)内存储的偏移值,得到物理地址.

这种简单的方法能够有效的防止进程得知自己的实际执行地址,不让它搞破坏.
## Swapping(3/28)
在第五章里我们提到了调度队列的问题,进程会经常在磁盘和内存之间交换,在这一节我们再来深入探讨交换的详细过程
### Standard Swapping(过)
这种交换方式在内存和备份存储之间进行,由于交换速度过慢,因此现代操作系统不使用标准交换
- ...我不知道这一节想表达什么

## 内存分配
>In the **variable-partition** scheme, the operating system keeps a table
indicating which parts of memory are available and which are occupied.
Initially, all memory is available for user processes and is considered one
large block of available memory, a **hole**. 

another approach

数据库教材笔记

Sat, 14 Mar 2026 08:00:00 +0000

教材:« Database System Concepts »
- 这本书讲的还是比较全面的,但废话也很多,部分地方讲的不够深

Introduction to the Relational Model

Structure of Relational Databases

A relational database consists of a collection of tables, each of which is assigned a unique name.

In mathematical terminology, a tuple is simply a sequence(or list) of values. A relationship between n values is represented mathematically by an n-tuple of values, that is, a tuple with n values, which corresponds to a row in a table.

Thus, in the relational model:

the term relation is used to refer to a table;
the term tuple is used to refer to a row;
the term attribute refers to a column of a table.

For each attribute of a relation, there is a set of permitted values, called the domain of that attribute. Thus, the domain of the salary attribute of the instructor relation is the set of all possible salary values, while the domain of the name attribute is the set of all possible instructor names.

A domain is atomic if elements of the domain are considered to be indivisible units.For example, suppose the table instructor had an attribute phone number, which can store a set of phone numbers corresponding to the instructor. Then the domain of phone number would not be atomic, since an element of the domain is a set of phonenumbers, and it has subparts, namely, the individual phone numbers in the set.

如果一个域的值在逻辑上/使用上还能再拆成更小的有意义的单元，那它就不是原子的

The null value is a special value that signiﬁes that the value is unknown or does not exist.

Database Schema

schema: the logical design of the database
- 即数据库中所有关系,属性的处理
- 这个概念其实很重要,会在之后多次出现.

Keys

superkey: a set of one or more attributes that identify uniquely a tuple in the relation.

For example, the ID attribute of the relation instructor is suﬃcient to distinguish one instructor tuple from another. Thus, ID is a superkey. The name attribute of instructor, on the other hand, is not a superkey, because several instructors might have the same name.

candidate keys: superkeys for which no proper subset is a superkey.

It is possible that several distinct sets of attributes could serve as a candidate key. Suppose that a combination of name and dept name is suﬃcient to distinguish among members of the instructor relation. Then, both {ID} and {name, dept name} are candidate keys. Although the attributes ID and name together can distinguish instructor tuples, their combination, {ID, name}, does not form a candidate key, since the attribute ID alone is a candidate key.

primary key: denote a candidate key that is chosen by the database designer as the principal means of identifying tuples within a relation
- 在这里,primary key可以是由多个attribute组成的tuple

The primary key should be chosen such that its attribute values are never, or are very rarely, changed.

Schema Diagrams

A database schema, along with primary key and foreign-key constraints, can be depicted by schema diagrams

Primary-key attributes are shown underlined. Foreign-key constraints appear as arrows from the foreign-key attributes of the referencing relation to the primary key of the referenced relation. We use a two-headed arrow, instead of a single-headed arrow, to indicate a referential integrity constraint that is not a foreign-key constraints.

Relational Query Languages

Query Language: A language used by a user to request information from a database. It operates at a higher level of abstraction than standard programming languages.
Categorization:
- Imperative Query Language: The user instructs the system to perform a specific sequence of operations. These languages maintain a notion of state variables that are updated during computation.
- Functional Query Language: Computation is expressed as the evaluation of functions. These functions operate on database data or results of other functions. They are side-effect free and do not update program state.
- Declarative Query Language: The user describes the desired information using mathematical logic without providing specific steps or function calls. The database system is responsible for determining the physical retrieval method.
Pure Query Languages:
- Relational Algebra: A functional query language that forms the theoretical basis of SQL.
- Tuple Relational Calculus and Domain Relational Calculus: Declarative languages.
Characteristics: These formal languages lack the “syntactic sugar” found in commercial languages but illustrate fundamental techniques for data extraction.

The Relational Algebra(3/26)

The Select Operation

σ dept_name = “Physics” (instructor)

We use the lowercase Greek letter sigma (σ) to denote selection.

We can ﬁnd all instructors with salary greater than $90,000 by writing: σ salary>90000 (instructor)

The Project Operation

Projection is denoted by the uppercase Greek letter pi (Π). Π ID, name, salary (instructor) The project operation is a unary operation that returns its argument relation, with certain attributes left out. 我们也可以在投影的时候进行计算: Π ID,salary∕12 (instructor)

Composition of Relational Operations

“Find the names of all instructors in the Physics department.”: Π name (σ dept_name = “Physics” (instructor))

The Cartesian-Product Operation

也就是说关系上的笛卡尔积会生成一个nxm大小的单元组表

The Join Operation

注意这里的join没有过滤掉重复的id列!

Set Operations

求并集(union)的前提条件:

输入的两个关系具有相同数量的属性
当属性相关联时,两个关系中对应属性的类型必须相同

求交集(intersection):

求集差(set-diﬀerence):

The Assignment Operation

It is convenient at times to write a relational-algebra expression by assigning parts of it to temporary relation variables. The assignment operation, denoted by ←, works like assignment in a programming language.

The Rename Operation

The rename operator refers to the results of relational-algebra expressions,denoted by the lowercase Greek letter rho (ρ).

Introduction to SQL

Overview of the SQL Query Language

The SQL language has several parts:
- Data-definition language (DDL). The SQL DDL provides commands for deﬁning relation schemas, deleting relations, and modifying relation schemas.
- Data-manipulation language (DML). The SQL DML provides the ability to query information from the database and to insert tuples into, delete tuples from, and modify tuples in the database.
  - 从这可以看到Data-manipulation是操作实例,Data-definition是操作关系模型
- Integrity. The SQL DDL includes commands for specifying integrity constraints that the data stored in the database must satisfy. Updates that violate integrity constraints are disallowed.
  - 即规范性.
- and so on

SQL Data Definition

Basic Types

The SQL standard supports a variety of built-in types, including:

char(n)
Fixed-length character string.
Exactly n characters long.
Padded with spaces if shorter value inserted.
Full form: character(n).
varchar(n)
Variable-length character string.
Maximum n characters.
Stores only actual characters (no padding).
Full form: character varying(n).
int
Integer.
Machine-dependent range (usually 32-bit).
Full form: integer.
smallint
Small integer.
Smaller machine-dependent range than int (usually 16-bit).
numeric(p, d)
Fixed-point (exact decimal) number.
Total digits: p (including sign).
Decimal places: d.
Example: numeric(3,1) stores -99.9 to 99.9 exactly.
Cannot store 444.5 (exceeds p) or 0.32 (needs d≥2).
real
Single-precision floating-point.
Machine-dependent precision (usually IEEE 32-bit).
double precision
Double-precision floating-point.
Machine-dependent higher precision (usually IEEE 64-bit).
float(n)
Floating-point with minimum precision of n decimal digits.
Implementation chooses actual precision ≥ n.

Each type may include a special value called the null value. A null value indicates an absent value that may exist but be unknown or that may not exist at all.

When comparing a char type with a varchar type, one may expect extra spaces to be added to the varchar type to make the lengths equal, before comparison; however, this may or may not be done, depending on the database system. As a result, even if the same value “Avi” is stored in the attributes A and B above, a comparison A=B may return false. We recommend you always use the varchar type instead of the char type to avoid these problems.

也就是说,可变数组在和固定长度数组比较时未必会加上对应长度的空格后再比较

Basic Schema Definition

We deﬁne an SQL relation by using the create table command. The following command creates a relation department in the database:

1
2
3
4
5
6
7


create table department
(
 dept_name vacchar(20),
 building varchar(15),
 budget numeric(12,2),
 primary key(dept_name)
);

结尾的;在大多数sql版本中是可选的

SQL supports a number of diﬀerent integrity constraints. In this section, we discuss only a few of them:

primary key: required to be nonnull and unique
- 也就是说不可重复,不可为null
- Although the primary-key speciﬁcation is optional, it is generally a good idea to specify a primary key for each relation.
foreign key(A) references s: the value of A in this relation must correspond to value of the primary key attributes in relation s.
- 也就是说不允许把s关系中不存在的值写在这个关系中
not null: the null value is not allowed for that attribute
drop table: remove a relation from an SQL database
- drop table r;只要这样就可以删除关系r了
delete from: retains relation r, but deletes all tuples in r.
- delete from r;
alter table: add or drop attributes to an existing relation
- alter table r add A D;:where r is the name of an existing relation, A is the name of the attribute to be added,and D is the type of the added attribute.
- alter table r drop A;: drop attributes from a relation eg

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


create table teaches
(
ID varchar (5),
course id varchar (8),
sec id varchar (8),
semester varchar (6),
year numeric (4,0),
primary key (ID, course id, sec id, semester, year),
foreign key (course id, sec id, semester, year) references section,
foreign key (ID) references instructor
);
alter table teaches drop ID;
drop table teaches;

Basic Structure of SQL Queries

The basic structure of an SQL query consists of three clauses: select, from, and where. A query takes as its input the relations listed in the from clause, operates on them as speciﬁed in the where and select clauses, and then produces a relation as the result.

事实上在部分语句或者某些数据库系统中where,from是可选的,但select是必须出现的

Queries on a Single Relation

1
2


select dept_name
from instructor;

Since more than one instructor can belong to a department, a department name could appear more than once in the instructor relation. We can rewrite the preceding query as:

1
2


select distinct dept name
from instructor;

The result of the above query would contain each department name at most once.

Also,SQL allows us to use the keyword all to specify explicitly that duplicates are not removed:

1
2


select all dept name
from instructor;

Since duplicate retention is the default, we shall not use all in our examples.

The select clause may also contain arithmetic expressions involving the operators +, −, ∗, and / operating on constants or attributes of tuples:

1
2


select ID, name, dept name, salary * 1.1
from instructor;

这不会改动原关系里的salary数值,只是在输出上将salary乘以1.1了

The where clause allows us to select only those rows in the result relation of the from clause that satisfy a speciﬁed predicate(断言)

1
2
3


select name
from instructor
where dept name = 'Comp. Sci.' and salary > 70000;

SQL allows the use of the logical connectives and, or, and not in the where clause. The operands of the logical connectives can be expressions involving the comparison operators <, <=, >, >=, =, and <>.

Queries on Multiple Relations

1
2
3


select instructor.dept_name, building, name
from instructor, department
where instructor.dept_name= department.dept_name;

注意到在不同关系中同时出现的attribute需要用关系名作为前缀来指明,而独特的attribute则不用

from解析 The from clause by itself deﬁnes a Cartesian product of the relations listed in the clause. It is deﬁned formally in terms of relational algebra, but it can also be understood as an iterative process that generates tuples for the result relation of the from clause.

1
2
3
4
5
6


for each tuple t1 in relation r1
 for each tuple t2 in relation r2
 …
 for each tuple tm in relation rm
 Concatenate t1 , t2 , … , tm into a single tuple t
 Add t into the result relation

也就是说from实际上会将所有关系用笛卡尔积制成一个nxm的表,如果不用where来过滤掉多余组合的话,在大型数据库中select将很难处理这么多数据

1
2


SELECT s.name, c.course_name
FROM students s, courses c;

→ 结果行数 = students 行数 × courses 行数（所有学生 × 所有课程的组合）

Additional Basic Operations

The Rename Operation

1
2
3


select name, course id
from instructor, teaches
where instructor.ID= teaches.ID;

The result of this query is a relation with the following attributes: name, course id

We cannot, however, always derive names in this way, for several reasons:

First, two relations in the from clause may have attributes with the same name, in which case an attribute name is duplicated in the result.

Second, if we use an arithmetic expression in the select clause, the resultant attribute does not have a name.

Third, even if an attribute name can be derived from the base relations as in the preceding example, we may want to change the attribute name in the result.

Hence, SQL provides a way of renaming the attributes of a result relation. It uses the as clause, taking the form: old-name as new-name

For example, if we want the attribute name name to be replaced with the name instructor_name, we can rewrite the preceding query as:

1
2
3


select name as instructor name, course id
from instructor, teaches
where instructor.ID= teaches.ID;

The as clause is particularly useful in renaming relations.

One reason to rename a relation is to replace a long relation name with a shortened version that is more convenient to use elsewhere in the query.

To illustrate, we rewrite the query “For all instructors in the university who have taught some course, find their names and the course ID of all courses they taught.”

1
2
3


select T.name, S.course_id
from instructor as T, teaches as S
where T.ID = S.ID;

Another reason to rename a relation is a case where we wish to compare tuples in the same relation. We then need to take the Cartesian product of a relation with itself and, without renaming, it becomes impossible to distinguish one tuple from the other.

Suppose that we want to write the query “Find the names of all instructors whose salary is greater than at least one instructor in the Biology department.”

We can write the SQL expression:

1
2
3


select distinct T.name
from instructor as T, instructor as S
where T.salary > S.salary and S.dept_name = 'Biology';

String Operations

SQL speciﬁes strings by enclosing them in single quotes, for example, ‘Computer’. A single quote character that is part of a string can be speciﬁed by using two single quote characters.

For example, the string “It’s right” can be speciﬁed by ‘It’’s right’.

The SQL standard speciﬁes that the equality operation on strings is case sensitive;as a result, the expression “‘comp. sci.’ = ‘Comp. Sci.’” evaluates to false.

但在MySQL和SQL Server中,在字符串比较时不区分大小写,故“‘comp. sci.’ = ‘Comp. Sci.’” 为真.

Pattern matching can be performed on strings using the operator like. We describe patterns by using two special characters:

Percent (%): The % character matches any substring.
Underscore (_): The character matches any character.

Patterns are case sensitive.To illustrate pattern matching, we consider the following examples:

‘Intro%’ matches any string beginning with “Intro”.
‘%Comp%’ matches any string containing “Comp” as a substring, for example, ‘Intro. to Computer Science’, and ‘Computational Biology’.
‘___’ matches any string of exactly three characters.
‘___%’ matches any string of at least three characters.

For patterns to include the special pattern characters (that is, % and ), SQL allows the speciﬁcation of an escape character. The escape character is used immediately before a special pattern character to indicate that the special pattern character is to be treated like a normal character. We deﬁne the escape character for a like comparison using the escape keyword. To illustrate, consider the following patterns, which use a backslash(∖) as the escape character:

like ‘ab∖%cd%’ escape ‘∖’ matches all strings beginning with “ab%cd”.
like ‘ab∖∖cd%’ escape ‘∖’ matches all strings beginning with “ab∖cd”.

也就是说,sql没有通用的转义符,而是需要用户定义并写入字符串中

SQL allows us to search for mismatches instead of matches by using the not like com- parison operator. Some implementations provide variants of the like operation that do not distinguish lower- and uppercase.

Attribute Specification in the Select Clause

The asterisk symbol “ * ” can be used in the select clause to denote “all attributes.”

1
2
3


select instructor.*
from instructor, teaches
where instructor.ID= teaches.ID;

It indicates that all attributes of instructor are to be selected.

Ordering the Display of Tuples

The order by clause causes the tuples in the result of a query to appear in sorted order.

By default, the order by clause lists items in ascending order. To specify the sort order, we may specify desc for descending order or asc for ascending order. Furthermore, ordering can be performed on multiple attributes. Suppose that we wish to list the entire instructor relation in descending order of salary. If several instructors have the same salary, we order them in ascending order by name. We express this query in SQL as follows:

1
2
3


select *
from instructor
order by salary desc, name asc;

Where-Clause Predicates

SQL includes a between comparison operator to simplify where clauses that specify that a value be less than or equal to some value and greater than or equal to some other value.

Similarly, we can use the not between comparison operator.

1
2
3


select name
from instructor
where salary between 90000 and 100000;

尽管它等价于以下语句,但看上去就直白了一点

1
2
3


select name
from instructor
where salary <= 100000 and salary >= 90000;

SQL permits us to use the notation (v1 , v2 , … , vn ) to denote a tuple of arity n con- taining values v1 , v2 , … , vn ; the notation is called a row constructor. The comparison operators can be used on tuples, and the ordering is deﬁned lexicographically. For ex- ample, (a1 , a2 ) <= (b1 , b2 ) is true if a1 <= b1 and a2 <= b2 ; similarly, the two tuples are equal if all their attributes are equal. Thus, the SQL query:

1
2
3


select name, course id
from instructor, teaches
where instructor.ID= teaches.ID and dept name = 'Biology';

can be rewritten as follows:

1
2
3


select name, course id
from instructor, teaches
where (instructor.ID, dept name) = (teaches.ID, 'Biology');

看似简写了,但其实看上去更懵了

Set Operations

The SQL operations union, intersect, and except operate on relations and correspond to the mathematical set operations ∪, ∩, and −.

The Union Operation

1
2
3
4
5
6
7


(select course id
from section
where semester = 'Fall' and year= 2017)
union
(select course id
from section
where semester = 'Spring' and year= 2018);

这里只是把两个结果合并了一下而已

Note that the parentheses we include around each select- from-where statement below are optional but useful for ease of reading.

The union operation automatically eliminates duplicates, unlike the select clause.

If we want to retain all duplicates, we must write union all in place of union.

The Intersect Operation

1
2
3
4
5
6
7


(select course id
from section
where semester = 'Fall' and year= 2017)
intersect
(select course id
from section
where semester = 'Spring' and year= 2018);

找交集

同样可以加一个all来保留相同字段

1
2
3
4
5
6
7


(select course id
from section
where semester = 'Fall' and year= 2017)
intersect all
(select course id
from section
where semester = 'Spring' and year= 2018);

The Except Operation

To ﬁnd all courses taught in the Fall 2017 semester but not in the Spring 2018 semester,we write:

1
2
3
4
5
6
7


(select course id
from section
where semester = 'Fall' and year= 2017)
except
(select course id
from section
where semester = 'Spring' and year= 2018);

The except operation outputs all tuples from its ﬁrst input that do not occur in the second input.

同样可以加一个all来保留相同字段

1
2
3
4
5
6
7


(select course id
from section
where semester = 'Fall' and year= 2017)
except all
(select course id
from section
where semester = 'Spring' and year= 2018);

Null Values

Null values present special problems in relational operations, including arithmetic operations, comparison operations, and set operations.

The result of an arithmetic expression (involving, for example, +, −, ∗, or ∕) is null.

If any of the input values is null. For example, if a query has an expression r.A + 5, and r.A is null for a particular tuple, then the expression result must also be null for that tuple.

也就是说null参与的数学运算结果都是null

Comparisons involving nulls are more of a problem.SQL therefore treats as unknown the result of any comparison involving a null value.This creates a third logical value in addition to true and false.

Since the predicate in a where clause can involve Boolean operations such as and,or, and not on the results of comparisons, the deﬁnitions of the Boolean operations are extended to deal with the value unknown.

and: The result of true and unknown is unknown, false and unknown is false, while unknown and unknown is unknown.
or: The result of true or unknown is true, false or unknown is unknown, while unknown or unknown is unknown.
not: The result of not unknown is unknown.

为什么这样设计?

TRUE AND UNKNOWN 为什么是 UNKNOWN?
- 如果 UNKNOWN 实际上是 TRUE：true and true = true
- 如果 UNKNOWN 实际上是 FALSE: true and false =false
- 由于结果可能是 TRUE 也可能是 FALSE，数据库无法给出定论，只能保守地标注为 UNKNOWN。
false and unknown 为什么是 false?
- 含有false的and语句恒为false,结果是确定的,故可标记为false.
true or unknown 为什么是 true?
- 同理,含有true的or语句恒为true.
false or unknown 为什么是 unknown?
- 同理,结果可能是 TRUE 也可能是 FALSE,无法定论.

SQL uses the special keyword null in a predicate to test for a null value. Thus, to ﬁnd all instructors who appear in the instructor relation with null values for salary, we write:

补充: 5*20+3=null,null=null,返回值都是unknown.

1
2
3


select name
from instructor
where salary is null;

有is null当然就有is not null.

SQL allows us to test whether the result of a comparison is unknown,by using the clauses is unknown and is not unknown.For example:

1
2
3


select name
from instructor
where salary > 10000 is unknown;

Aggregate Functions

Aggregate functions are functions that take a collection (a set or multiset) of values as input and return a single value. SQL oﬀers ﬁve standard built-in aggregate functions:

Average: avg
Minimum: min
Maximum: max
Total: sum
Count: count

Basic Aggregation

1
2
3


select avg (salary) as avg_salary
from instructor
where dept name = 'Comp. Sci.';

找到salary的平均值

1
2
3


select count (distinct ID)
from teaches
where semester = 'Spring' and year = 2018;

使用count关键字统计()内的具有对应属性的行数

Aggregation with Grouping

1
2
3


select dept_name, avg (salary) as avg salary
from instructor
group by dept_name;

这里把instructor用dept_name分组,从而统计出每个部门的avg_salary.

也就是说group by 需要在select语句中写明操作的对象,才能在结果中反映出来分组的结果

1
2
3
4


/* erroneous query */
select dept_name, ID, avg (salary)
from instructor
group by dept_name;

上述sql语句由于一个分组中的tuple可以有不同的id属性,故不能变成一个分组,会引发错误

总结一下: 当 SQL 查询包含 GROUP BY 子句时，SELECT 子句中的任何属性（列名）必须满足以下两个条件之一，否则该查询在逻辑上是错误的：

该属性出现在 GROUP BY 子句中。
该属性被包裹在聚合函数（如 SUM, COUNT, AVG, MAX, MIN）之中。

进阶版

1
2
3
4
5


select dept_name, count (distinct ID) as instr count
from instructor, teaches
where instructor.ID = teaches.ID and
semester = 'Spring' and year = 2018
group by dept_name;

“Find the number of instructors in each department who teach a course in the Spring 2018 semester.”

The Having Clause

为了处理分组,而不是处理分组后的tuples,引入了having clause.

1
2
3
4


select dept name, avg (salary) as avg_salary
from instructor
group by dept name
having avg (salary) > 42000;

上述语句会过滤掉ayg_salary小于等于42000的分组

The logical execution sequence of an SQL query containing aggregation, GROUP BY, or HAVING clauses is defined as follows:

Evaluate the FROM clause The FROM clause is first evaluated to generate a relation (the initial set of data from specified tables or joins).
Apply the WHERE clause (if present) The predicate in the WHERE clause is applied to the result relation of the FROM clause. Only tuples satisfying this predicate proceed.
Apply the GROUP BY clause (if present) Tuples satisfying the WHERE predicate are placed into groups based on the GROUP BY clause. If the GROUP BY clause is absent, the entire set of filtered tuples is treated as a single group.
Apply the HAVING clause (if present) The HAVING clause is applied to each group. Groups that do not satisfy the HAVING clause predicate are removed entirely.
Evaluate the SELECT clause The SELECT clause uses the remaining groups to generate the final result tuples. Aggregate functions are applied here to produce a single result tuple for each group.

长难句分析

1
2
3
4
5


select course_id, semester, year, sec_id, avg (tot_cred)
from student, takes
where student.ID= takes.ID and year = 2017
group by course_id, semester, year, sec_id
having count (ID) >= 2;

这里把学生按照“班级”扔进不同的筐里。比如“数据库-2017-秋-01班”是一个筐，“算法-2017-秋-02班”是另一个筐

也就是说,group by后面的属性全部相同时才会被归为一组

Aggregation with Null and Boolean Values

1
2


select sum (salary)
from instructor;

当salary中有null值的时候,并不会像普通的5+null=null一样返回null,而是会忽略null

In general, aggregate functions treat nulls according to the following rule: All aggre- gate functions except count (*) ignore null values in their input collection. As a result of null values being ignored, the collection of values may be empty. The count of an empty collection is deﬁned to be 0, and all other aggregate operations return a value of null when applied on an empty collection

由于count是统计行数的,故当某一行有null时也会计入

Nested Subqueries

A subquery is a select-from-where expression that is nested within another query. A common use of subqueries is to perform tests for set membership, make set comparisons, and determine set cardinality by nesting subqueries in the where clause.

Set Membership

1
2
3
4
5
6


select distinct course_id
from section
where semester = 'Fall' and year= 2017 and
course_id in (select course_id
 from section
 where semester = 'Spring' and year= 2018);

We use the not in construct in a way similar to the in construct. For example, to ﬁnd all the courses taught in the Fall 2017 semester but not in the Spring 2018 semester, which we expressed earlier using the except operation, we can write:

1
2
3
4
5
6


select distinct course id
from section
where semester = 'Fall' and year= 2017 and
course id not in (select course id
from section
where semester = 'Spring' and year= 2018);

也就是说,之前提到的intersect和except都可以用subquery的形式来解决

Set Comparison

The phrase “greater than at least one” is represented in SQL by > some.

1
2
3
4
5


select name
from instructor
where salary > some (select salary
from instructor
where dept_name = 'Biology');

SQL also allows < some, <= some, >= some, = some, and <> some comparisons. As an exercise, verify that = some is identical to in, whereas <> some is not the same as not in.

The construct > all corresponds to the phrase “greater than all.”

1
2
3
4
5


select name
from instructor
where salary > all (select salary
from instructor
where dept name = 'Biology');

As it does for some, SQL also allows < all, <= all, >= all, = all, and <> all comparisons. As an exercise, verify that <> all is identical to not in, whereas = all is not the same as in.

Test for Empty Relations

The exists construct returns the value true if the argument subquery is nonempty.

1
2
3
4
5
6
7
8


select course_id
from section as S
where semester = 'Fall' and year= 2017 and
 exists (select *
 from section as T
 where semester = 'Spring' 
 and year= 2018 
 and S.course_id= T .course_id);

The above query also illustrates a feature of SQL where a correlation name from an outer query (S in the above query), can be used in a subquery in the where clause. A subquery that uses a correlation name from an outer query is called a correlated subquery.

当然,有exists就有not exists:

1
2
3
4
5
6
7
8
9


select S.ID, S.name
from student as S
where not exists ((select course_id
 from course
 where dept_name = 'Biology')
 except
 (select T .course_id
 from takes as T
 where S.ID = T .ID));

长难句分析 首先计算“Biology 系开设了，但该学生没选”的课程,如果这类课程not exists,说明该学生选了所有Biology系的课程.

Test for the Absence of Duplicate Tuples(3/18)

Using the unique construct, we can write the query “Find all courses that were oﬀered at most once in 2017” as follows:

如果你记忆力够好的话,可能会记得之前在create table的时候会用unique来保证对应的属性不能有重复值

1
2
3
4
5
6


select T .course id
from course as T
where unique (select R.course id
from section as R
where T .course id= R.course id and
R.year = 2017);

Note that if a course were not oﬀered in 2017, the subquery would return an empty result, and the unique predicate would evaluate to true on the empty set. 也就是说即使结果为空,但由于是unique,故也会返回true.

当然,有了unique就有not unique,要求返回结果中的每个tuple至少出现两次

1
2
3
4
5
6


select T .course id
from course as T
where not unique (select R.course id
 from section as R
 where T .course id= R.course id and
 R.year = 2017);

可以看到,where部分的subquery可以访问外层的关系

Subqueries in the From Clause

1
2
3
4
5
6


select dept name, avg salary
from (select dept name, avg (salary)
 from instructor
 group by dept name)
 as dept avg (dept name, avg salary)
where avg salary > 42000;

是的,from的关系也能用别名…

但是值得注意的是,在from中的subquery不能访问外层的关系,因为from中的关系是相互并列的,不存在嵌套关系,只能通过lateral关键字来强制让后继关系能够获取前置关系

1
2
3
4


select name, salary, avg_salary
from instructor I1, lateral (select avg(salary) as avg_salary
from instructor I2
where I2.dept name= I1.dept_name);

如果你跟我一样从头看到这里的话,你会清楚的记得前面都是写类似instructor as I1的方式来起别名的,但是as实际上是可选的!尽管这里并没有提到这一点-这也是我讨厌这本教材的原因之一.

The With Clause

The with clause provides a way of deﬁning a temporary relation whose deﬁnition is available only to the query in which the with clause occurs.

1
2
3
4
5
6


with max_budget (value) as
 (select max(budget)
 from department)
select budget
from department, max_budget
where department.budget = max_budget.value;

注意到这里是先写别名再在as后写原关系,而我们之前都是先写原关系再写as的

with得到的是关系而非属性,因此我们每次都需要用关系(属性)的方式来使用with

实际上,上述的with语句完全可以放到where中

1
2
3


select budget
from department
where budget = (select max(budget) from department);

We could have written the preceding query by using a nested subquery in either the from clause or the where clause. However, using nested subqueries would have made the query harder to read and understand. The with clause makes the query logic clearer; it also permits this temporary relation to be used in multiple places within a query.

Scalar(标量) Subqueries

SQL allows subqueries to occur wherever an expression returning a value is permitted,provided the subquery returns only one tuple containing a single attribute; such sub-queries are called scalar subqueries.

也就是说只返回一行一列 长难句分析

1
2
3
4
5
6


select dept_name,
 (select count(*)
 from instructor
 where department.dept_name = instructor.dept_name)
 as num_instructors
from department;

select count(*)在这里是无论是否有空值都返回满足epartment.dept_name = instructor.dept_name的所有行的意思

Scalar Without a From Clause

1
2
3
4


(select count (*) from teaches) / (select count (*) from instructor);
-- 在某些数据库中会由于没有from语句而报错
select (select count (*) from teaches) / (select count (*) from instructor) from dual;
-- 提供了一个dummy relation来提供from语句且不产生其他副作用

Modification of the Database(3/19)

Deletion

A delete request is expressed in much the same way as a query. We can delete only whole tuples; we cannot delete values on only particular attributes. SQL expresses a deletion by:

1
2
3
4


delete from r
where P;
-- where P represents a predicate and r represents a relation.
-- The where clause can be omitted, in which case all tuples in r are deleted.

1
2
3


delete from instructor
where salary between 13000 and 15000;
-- Delete all instructors with a salary between $13,000 and $15,000.

事实上delete与select的用法没有什么区别,只不过一个是选择关系,一个是删除关系而已.

Insertion

The attribute values for inserted tuples must be members of the corresponding attribute’s domain. Similarly, tuples inserted must have the correct number of attributes.

1
2
3
4
5
6
7
8
9


insert into course
values ('CS-437', 'Database Systems', 'Comp. Sci.', 4);

-- 如果忘记了表的顺序,那么可以具体写出属性名来插入,这三种写法的结果完全相同
insert into course (course id, title, dept name, credits)
values ('CS-437', 'Database Systems', 'Comp. Sci.', 4);

insert into course (title, course id, credits, dept name)
values ('Database Systems', 'CS-437', 4, 'Comp. Sci.');

1
2
3
4


insert into instructor
 select ID, name, dept name, 18000
 from student
 where dept name = 'Music' and tot cred > 144;

当然,我们可以从其他关系中获取tuple后再插入,而不是只用value来具体写.

Updates

n certain situations, we may wish to change a value in a tuple without changing all values in the tuple. For this purpose, the update statement can be used.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


update instructor
set salary= salary * 1.05;
-- 我们可以对某一列属性整体生效

update instructor
set salary = salary * 1.05
where salary < 70000;
-- 也可以对该列属性的部分值生效

update instructor
set salary = salary * 1.05
where salary < (select avg (salary)
from instructor);
-- 还可以对满足子查询的属性值生效

进阶写法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


update instructor
set salary = case
 when salary <= 100000 then salary * 1.05
 else salary * 1.03
 end
-- 具体模板如下
-- case
 -- when pred 1 then result1
 -- when pred 2 then result2
 -- …
 -- when pred n then resultn
 -- else result0
-- end

Intermediate SQL(3/15)

Join Expressions

事实上,单独的join语句不加任何前缀和后缀会报错,因为不存在只写一个join而不进行过滤操作的语法.

The Natural Join

1
2
3


select name, course_id
from student, takes
where student.ID = takes.ID;

上述语句在执行的中间结果中会保留两个ID列,只是在select时抛弃掉了而已.

1
2


select name, course id
from student natural join takes;

而natural join的中间结果只保留一个ID列规则:

找到同名列
过滤掉同名列中的值不相等的行
两个同名列只保留一列

1
2


select name, title
from (student natural join takes) join course using (course_id);

The operation join … using requires a list of attribute names to be speciﬁed. Both relations being joined must have attributes with the speciﬁed names.

也就是说只用using()里面那个属性在join的时候来判断,而不像natural join一样在有多个同名属性的情况下全都要求相等.

Join Conditions

The on condition allows a general predicate over the relations being joined.

1
2


select *
from student join takes on student.ID = takes.ID;

完全等价于下面语句,也就是结果都保持了两个ID列

1
2
3


select *
from student, takes
where student.ID = takes.ID;

所以基本用不上on

Outer Joins

1
2


select *
from student natural join takes;

由于natural join会丢弃takes.id!=student.id的行,对于只在一个表中存在的ID,由于在另一个表中找不到对等的值,也会被抛弃,但在实际需求中,即使没选课的学生,我们也希望展示出来,故这里需要使用outer join.

There are three forms of outer join:

The left outer join preserves tuples only in the relation named before the left outer join operation.
The right outer join preserves tuples only in the relation named after the right outer join operation.
The full outer join preserves tuples in both relations.

In contrast, the join operations we studied earlier that do not preserve nonmatched tuples are called inner-join operations, to distinguish them from the outer-join operations.

We now explain exactly how each form of outer join operates. We can compute the left outer-join operation as follows: First, compute the result of the inner join as before. Then, for every tuple t in the left-hand-side relation that does not match any tuple in the right-hand-side relation in the inner join, add a tuple r to the result of the join constructed as follows:

The attributes of tuple r that are derived from the left-hand-side relation are ﬁlled in with the values from tuple t.
The remaining attributes of r are ﬁlled with null values.

1
2


select *
from student natural left outer join takes;

如果对于在student里出现但在takes里没有的id,会将student表中的值填入,对应takes部分的值均为null.

The full outer join is a combination of the left and right outer-join types. After the operation computes the result of the inner join, it extends with nulls those tuples from the left-hand-side relation that did not match with any from the right-hand-side relation and adds them to the result. Similarly, it extends with nulls those tuples from the right- hand-side relation that did not match with any tuples from the left-hand-side relation and adds them to the result. Said diﬀerently, full outer join is the union of a left outer join and the corresponding right outer join.

也就是说保留两边的缺值

进阶例子

1
2
3
4
5
6
7
8


select *
from (select *
from student
where dept name = 'Comp. Sci.')
natural full outer join
(select *
from takes
where semester = 'Spring' and year = 2017);

一开始明明都是用student natural full outer join takes的,这里为什么要单独把两个结果提出来呢?

1
2
3
4
5
6


select *
from student
natural full outer join takes
where dept_name = 'Comp. Sci.'
 and semester = 'Spring'
 and year = 2017;

因为如果这样写的话,尽管在from部分保留了null,但where部分又把null全部过滤掉了

The on condition is part of the outer join speciﬁcation, but a where clause is not.

1
2


select *
from student left outer join takes on student.ID = takes.ID;

也就是说上面这个语句不等价于下面的,因为on是在join阶段生效,即使不匹配也会置为null; 而where是在join之后生效,因此where会过滤掉null行,而上面语句中的on则会保留

1
2
3


select *
from student left outer join takes on true
where student.ID = takes.ID;

Join Types and Conditions

The keyword inner is optional:

1
2


select *
from student join takes using (ID);

is equivalent to:

1
2


select *
from student inner join takes using (ID);

Similarly, natural join is equivalent to natural inner join.

Views

SQL allows a “virtual relation” to be deﬁned by a query, and the relation conceptually contains the result of the query. The virtual relation is not precomputed and stored but instead is computed by executing the query whenever the virtual relation is used.

因此就有了view这个概念用来代表尚未执行的sql语句

View Definition

1

create view v as <query expression>;

where < query expression > is any legal query expression. The view name is represented v

1
2
3


create view faculty as
select ID, name, dept name
from instructor;

通过这样写,可以给低权限用户传递view这个关系而不直接接触instructor这个关系.

Using Views in SQL Queries

The attribute names of a view can be speciﬁed explicitly as follows:

1
2
3
4


create view departments total salary(dept name, total salary) as
select dept name, sum (salary)
from instructor
group by dept name;

Since the expression sum(salary) does not have a name, the attribute name is speciﬁed explicitly in the view deﬁnition.

Update of a View

Not recommended!

Transactions

blablabla…

Integrity Constraints

Constraints on a Single Relation

not null
unique
check()

Not Null Constraint

1
2


name varchar(20) not null
budget numeric(12,2) not null

The not null constraint prohibits the insertion of a null value for the attribute, and is an example of a domain constraint.

Unique Constraint

The unique speciﬁcation says that no two tuples in the relation can be equal on all the listed attributes.

The Check Clause

When applied to a relation declaration, the clause check(P) speciﬁes a predicate P that must be satisﬁed by every tuple in a relation.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


create table section
(course id
 varchar (8),
sec id
 varchar (8),
semester
 varchar (6),
year
 numeric (4,0),
building
 varchar (15),
room number varchar (7),
time slot id varchar (4),
primary key (course id, sec id, semester, year),
check (semester in ('Fall', 'Winter', 'Spring', 'Summer')));

Here, we use the check clause to simulate an enumerated type by specifying that semester must be one of ‘Fall’, ‘Winter’, ‘Spring’, or ‘Summer’.

还可以把check写在定义的属性之后

 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


CREATE TABLE classroom (
 building VARCHAR(15),
 room_number VARCHAR(7),
 capacity NUMERIC(4,0),
 PRIMARY KEY (building, room_number)
);

CREATE TABLE department (
 dept_name VARCHAR(20),
 building VARCHAR(15),
 budget NUMERIC(12,2) CHECK (budget > 0),
 PRIMARY KEY (dept_name)
);

CREATE TABLE course (
 course_id VARCHAR(8),
 title VARCHAR(50),
 dept_name VARCHAR(20),
 credits NUMERIC(2,0) CHECK (credits > 0),
 PRIMARY KEY (course_id),
 FOREIGN KEY (dept_name) REFERENCES department 
);

CREATE TABLE instructor (
 ID VARCHAR(5),
 name VARCHAR(20) NOT NULL,
 dept_name VARCHAR(20),
 salary NUMERIC(8,2) CHECK (salary > 29000),
 PRIMARY KEY (ID),
 FOREIGN KEY (dept_name) REFERENCES department 
);

CREATE TABLE section (
 course_id VARCHAR(8),
 sec_id VARCHAR(8),
 semester VARCHAR(6) CHECK (semester IN ('Fall', 'Winter', 'Spring', 'Summer')),
 year NUMERIC(4,0) CHECK (year > 1759 AND year < 2100),
 building VARCHAR(15),
 room_number VARCHAR(7),
 time_slot_id VARCHAR(4),
 PRIMARY KEY (course_id, sec_id, semester, year),
 FOREIGN KEY (course_id) REFERENCES course ,
 FOREIGN KEY (building, room_number) REFERENCES classroom 
);

Referential Integrity

默认引用 (Implicit Reference) foreign key (dept_name) references department

底层行为：当你省略括号中的属性名时，SQL 标准规定该外键必须引用被参照表的 主键 (Primary Key)

显式引用 (Explicit Reference) foreign key (dept_name) references department(dept_name)

底层行为：目标列（dept_name）不必是主键，但必须具有唯一性约束 (UNIQUE) 或本身就是主键。即它必须是一个超键 (Superkey)。

Assigning Names to Constraints

1
2
3
4


-- 使用constraint关键字命名该限制
salary numeric(8,2), constraint minsalary check (salary > 29000),
-- 删除该限制
alter table instructor drop constraint minsalary;

Complex Check Conditions and Assertions

An assertion is a predicate expressing a condition that we wish the database always to satisfy.

格式

1

create assertion <assertion-name> check <predicate>;

1
2
3
4
5
6
7


create assertion credits earned constraint check
(not exists (select ID
 from student
 where tot_cred <> (select coalesce(sum(credits), 0)
 from takes natural join course
 where student.ID= takes.ID
 and grade is not null and grade<> ’F’ )))

非常好的是这种东西不会考,因为主流数据库也不用

SQL Data Types and Schemas

There are additional built-in data types supported by SQL, which we describe below.

Date and Time Types in SQL

date: A calendar date containing a (four-digit) year, month, and day of the month.
time: The time of day, in hours, minutes, and seconds.
timestamp: A combination of date and time.

Date and time values can be speciﬁed like this:

1
2
3
4


date '2018-04-25'
-- Dates must be speciﬁed in the format year followed by month followed by day
time '09:30:00'
timestamp '2018-04-25 10:29:01.45'

Type Conversion and Formatting Functions(过)

由于我找到了中文版教材,故从现在开始大部分使用中文版,少部分使用英文版(因为这本书真的是又臭又长)

1. 显式类型转换 (Type Casting) 语法： cast(expression as data_type)
用途： 物理改变数据的解析方式，常用于修正字符串排序逻辑。

1
2
3
4
5
6
7


/* 修正前：'11' 会排在 '2' 前面（字符串字典序） */
select ID from instructor order by ID;

/* 修正后：将字符串物理转为数字，实现数值大小排序 */
select ID 
from instructor 
order by cast(ID as numeric);

2. 格式化函数 (Formatting Functions) 用途： 不改变物理类型，只给数据套上“显示滤镜”。各数据库系统实现不同。

1
2
3
4
5
6
7
8


-- MySQL: 数字千分位格式化
select format(salary, 2) from instructor; 

-- PostgreSQL/Oracle: 日期转特定格式字符串
select to_char(now(), 'YYYY-MM-DD'); 

-- SQL Server: 风格化转换
select convert(varchar, getdate(), 101); -- 返回 mm/dd/yyyy

3. 空值合并 (Coalesce) 语法： coalesce(arg1, arg2, ...)
逻辑： 物理扫描参数列表，返回第一个非 null 的值。要求所有参数物理类型一致。

1
2
3
4
5


/* 如果 salary 是 null，物理替换为 0 以便后续数学运算 */
select ID, coalesce(salary, 0) as actual_salary
from instructor;

/* 错误示例：coalesce(salary, 'N/A') 会报错，因为数字和字符串类型不匹配 */

4. 条件解码 (Decode - Oracle 特有) 语法： decode(value, search, result, default)
逻辑： 类似于 switch-case。它允许 null = null 的物理匹配，且不强制要求类型一致。

1
2
3


/* 将物理空值直接翻译成业务描述字符串 'N/A' */
select ID, decode(salary, null, 'N/A', salary) as salary_text
from instructor;

随便一看就知道不会考的…

Default Values

SQL allows a default value to be speciﬁed for an attribute as illustrated by the following create table statement:

1
2
3
4
5
6


create table student
 (ID varchar (5),
 name varchar (20) not null,
 dept_name varchar (20),
 tot_cred numeric (3,0) default 0,
 primary key (ID));

Large-Object Types

SQL provides large-object data types for character data (clob) and binary data (blob). The letters “lob” in these data types stand for “Large OBject.”

1
2
3


book_review clob(10KB)
image blob(10MB)
movie blob(2GB)

User-Defined Types(过)

SQL supports two forms of user-deﬁned data types. The ﬁrst form, which we cover here, is called distinct types.

The create type clause can be used to deﬁne new types:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


create type Dollars as numeric(12,2) ﬁnal;
create type Pounds as numeric(12,2) ﬁnal;

create table department
(dept name
 varchar (20),
building
 varchar (15),
budget
 Dollars);

这一节也不重要,因为主流数据库也不支持

Generating Unique Key Values

1
2
3
4
5
6


ID number(5) generated always as identity
-- When the always option is used, any insert statement must avoid specifying a value
-- for the automatically generated key. 

insert into instructor (name, dept_name, salary)
values ('Newprof', 'Comp. Sci.', 100000);

Create Table Extensions

Applications often require the creation of tables that have the same schema as an existing table.

1
2


-- SQL provides a create table like extension to support this task
create table temp_instructor like instructor;

Schemas, Catalogs, and Environments(过)

Index Definition in SQL(过)

由于这部分基本什么都没讲,还是得到index章节去看

Authorization

We may assign a user several forms of authorizations on parts of the database. Authorizations on data include:

• Authorization to read data. • Authorization to insert new data. • Authorization to update data. • Authorization to delete data.

Each of these types of authorizations is called a privilege.

Granting and Revoking of Privileges

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


-- grant的使用格式
grant <privilege list>
on <relation name or view name>
to <user/role list>;

-- grants database users Amit and Satoshi select authorization on the department relation:
grant select on department to Amit, Satoshi;

-- If the list of attributes is omitted, the update privilege will be granted on all attributes of the relation.
grant update (budget) on department to Amit, Satoshi;

-- To revoke an authorization, we use the revoke statement. It takes a form almost identical to that of grant:
revoke <privilege list>
on <relation name or view name>
from <user/role list>;

revoke select on department from Amit, Satoshi;
revoke update (budget) on department from Amit, Satoshi;

Roles

我们使用Roles来解决需要多次指定相同权限的问题

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


create role instructor;

-- Roles can then be granted privileges just as the users can,
grant select on takes
to instructor;

-- Roles can be granted to users, as well as to other roles,
create role dean;
grant instructor to dean;
grant dean to Satoshi;

Authorization on Views

1
2
3
4
5
6
7
8
9


-- 为了让某个工作人员能够看到地质系的所有教师但不能看到其他系的教师表,我们可以这样写:
create view geo_instructor as
(select *
from instructor
where dept name = 'Geology');

-- 但是,下面的操作实际上还是间接的访问了instructor表
select *
from geo_instructor;

Authorizations on Schema

SQL includes a references privilege that permits a user to declare foreign keys when creating relations.

1

grant references (dept_name) on department to Mariano;

为什么要限制引用外码呢?

However, recall that foreign-key constraints restrict deletion and update operations on the referenced relation. Suppose Mariano creates a foreign key in a relation r referencing the dept name attribute of the department relation and then inserts a tuple into r pertaining to the Geology department. It is no longer possible to delete the Geology department from the department relation without also modifying relation r.

Transfer of Privileges

当我们授予某用户一个权限时,默认他是无法将获得的权限传递给其他用户的,如果希望他能够传递权限,我们可以这样写:

1

grant select on department to Amit with grant option;

当然,关系/视图/角色(relation/view/role) 的创建者拥有该对象的所有权限并且可以给其他用户授权(不然就没人能授权了)

Revoking of Privileges(过)

Advanced SQL

事实上,这部分我觉得期末不考,我猜老师自己也不会😅
- (4/8): 第一次小测考了前三节,…

Accessing SQL from a Programming Language(过)

JDBC

你猜怎么着,我们的课程安排是在学完这门课后再学java…

The JDBC standard deﬁnes an application program interface (API) that Java programs can use to connect to database servers. (The word JDBC was originally an abbreviation for Java Database Connectivity, but the full form is no longer used.)

ODBC

The Open Database Connectivity (ODBC) standard deﬁnes an API that applications can use to open a connection with a database, send queries and updates, and get back results.

Functions and Procedures(待补充)

Triggers(待补充)

A trigger is a statement that the system executes automatically as a side eﬀect of a modiﬁcation to the database.

也就是说,trigger是一个满足条件时自动执行的函数

第一次小测复习

ch1

使用文件处理系统而不是数据库的弊端

Data redundancy and inconsistency: 可能有多个文件记录了相同的信息,又或者不同文件的记录不相同,没有同步更新
Diﬃculty in accessing data: 普通的编程语言不能做到用高效又便利的方式取回数据
Data isolation: 数据被存储在不同类型的不同文件中,很难统一管理
Integrity problems: 很难通过普通的编程语言去给存储的数据加上各种限制
Atomicity problems: 转账时,如果在付款方付钱后系统故障,那么收款方账户未必会收到钱,但付款方账户已经扣了钱.也就是说,很难实现这样一种效果:要么两边操作全都发生,要么都不发生
Concurrent-access anomalies: 并发访问数据时可能导致异常
Security problems: 很难设置不同管理员的权限

数据库结构的基础: 数据模型

本书介绍了4种模型:

Relational Model: uses a collection of tables to represent both data and the relationships among those data. Each table has multiple columns, and each column has a unique name. Tables are also known as relations.
Entity-Relationship Model: The entity-relationship (E-R) data model uses a collection of basic objects, called entities, and relationships among these objects.
Semi-structured Data Model: individual data items of the same type may have diﬀerent sets of attributes.
Object-Based Data Model: 仅仅是第一种类型的扩展,适用于面向对象的编程语言

ch2: Introduction to the Relational Model

schema到底是什么

Relation Schema（关系模式）：对应编程中的“类型定义”或“类声明”。
- 物理组成：由属性名（Attributes）及其对应的域（Domains/Data Types）组成。
- 示例分析：department (dept_name, building, budget) 物理规定了任何存入该表的记录必须且只能包含这三个维度。
Database Schema（数据库模式）：对应软件架构中的“逻辑设计”。

ch3

数据类型

char(n): 固定长度为n的字符串
varchar(n): 最大长度为n的可变长字符串
int: 整数
numeric(p,d): 有p位数字(加上一个符号位)和小数点右边的p位中的d位数字
float(n): 精度至少为n位数字的浮点数

操纵关系表

创建表时可以对变量使用以下六个限制:

primary key(d): d非空且唯一
foreign key(d) references s: d的值必须出现在s的对应主码上
foreign key(d) references s(t): d的值必须与t对应,要求t是唯一的,即具有unique约束
not null: 非空
unique: 唯一
check(d…): 要求新加入的d满足对应条件,否则插入时报错

1
2
3
4
5
6


create table department(
 dept_name varchar(20) not null,
 building varchar(15) unique,
 budget numeric(12,2),check(buget>0),
 primary key(dept_name)
);

删除表或更改属性

1
2
3
4
5
6


-- 删除表r
drop table r;

-- 增加(删除)属性A,类型为D
alter table r add A D;
-- alter table r drop A 很多数据库系统不支持

删除元组

1
2
3
4
5


-- 删除表r中的所有元组,保留框架
delete from r;
-- 删除满足条件P的元组
delete from r
where P;

插入元组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


-- 需要按照属性名顺序来,否则可能会插入失败
insert into r
 values(a1,a2,a3,....)
-- 指定插入值的对应属性
insert into course (course id, title, dept name, credits)
values ('CS-437', 'Database Systems', 'Comp. Sci.', 4);

-- 插入查询结果
insert into instructor
select ID, name, dept_name, 18000
from student
where dept name = 'Music' and tot_cred > 144;

更新元组

1
2
3
4


-- 更改满足条件的属性名
update instructor
set salary = salary * 1.05
where salary < 70000;

select…from…where

select基础部分

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


-- !!!select会选中null行,不自动过滤!!!
-- 默认启用all保留重名行
select (all) dept_name
from instructor;
-- 去掉重名行
select distinct dept_name
from instructor;
-- 简单计算
select ID,salary*1.1
from insructor;

-- 选中所有关系的所有属性
select *
from instructor
-- 选中一个关系的所有属性
select instructor.*
from instructor, teaches
where instructor.ID= teaches.ID;

select进阶部分

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


-- max,min,avg,sum:均为op(attribute)格式
select avg (salary)
from instructor
where dept_name = 'Comp. Sci.';
-- 启用as
select avg (salary) as avg_salary
from instructor
where dept_name = 'Comp. Sci.';

-- count(attribute)和count(*)

-- count(attribute): 过滤重名行,一个ID统计一行,但会忽略ID为null的行
select count (distinct ID)
from teaches
where semester = 'Spring' and year = 2018;

-- count(*): 统计所有行,包括存在空值的行
select count (*)
from course;

from基础部分

1
2
3
4


-- 启用as
select T .name, S.course_id
from instructor as T , teaches as S
where T .ID= S.ID; 

where基础部分

 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


-- =判断符
select name
from instructor
where dept_name = 'Comp. Sci.'
-- >,<,>=,<=判断符
select distinct T .name
from instructor as T , instructor as S
where T.salary > S.salary
-- and,or联结词
select name
from instructor
where dept_name = 'Comp. Sci.' and salary > 70000;
-- (not) between...and...联结词
select name
from instructor
where salary between 90000 and 100000;
-- 等价于
select name
from instructor
where salary <= 100000 and salary >= 90000;


-- 字符串比较: like,not like
-- 注意sql中只有单引号,没有双引号
-- %: 匹配任意子串
-- _: 匹配任意一个字符
-- ___%: 匹配至少含有任意三个字符的字符串

select dept_name
from department
where building like '%Watson%';

where进阶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


-- 构造器写法: (a,b)=(c,d)-> a=c and b=d
select name, course_id
from instructor, teaches
where (instructor.ID, dept_name) = (teaches.ID, 'Biology');

-- unknown: 如果对于某一个元组来说,判断符(即使是=)的一边为null,那么结果就是unkown ,则该元组不能被加入到结果中

-- is (not) null,is (not) unknown
select name
from instructor
where salary is null;

select name
from instructor
where salary > 10000 is unknown;
-- 解释: 只有salary为null的行才可以出现在结果中

where中的子查询

in,not in

1
2
3
4
5
6


select distinct course_id
from section
where semester = 'Fall' and year= 2017 and
course_id in (select course_id
 from section
 where semester = 'Spring' and year= 2018);

some

1
2
3
4
5
6


select name
from instructor
where salary > some (select salary
from instructor
where dept_name = 'Biology');
-- 至少比生物学部门的一个老师工资要高

SQL also allows < some, <= some, >= some, = some, and <> some comparisons. As an exercise, verify that = some is identical to in, whereas <> some is not the same as not in. all

1
2
3
4
5
6


select name
from instructor
where salary > all (select salary
from instructor
where dept_name = 'Biology');
-- 比生物学部门的所有老师工资都高

SQL also allows < all, <= all, >= all, = all, and <> all comparisons. As an exercise, verify that <> all is identical to not in, whereas = all is not the same as in. (not) exists

1
2
3
4
5
6
7
8


select course_id
from section as S
where semester = 'Fall' and year= 2017 and
 exists (select *
 from section as T
 where semester = 'Spring' 
 and year= 2018 
 and S.course_id= T .course_id);

exists的原理: 当括号内的查询第一次被满足时即返回true,让sql引擎继续扫描下一行.

unique

1
2
3
4
5
6


select T .course id
from course as T
where unique (select R.course id
from section as R
where T .course id= R.course id and
R.year = 2017);

如果无重复元组则返回true,无论元组是否为空

from中的子查询

1
2
3
4
5
6


select dept_name, avg_salary
from (select dept_name, avg (salary)
 from instructor
 group by dept_name)
 as dept_avg (dept_name, avg_salary)
where avg_salary > 42000;

with: 子查询的变种

1
2
3
4
5
6


with max_budget (value) as
(select max(budget)
from department)
select budget
from department, max_budget
where department.budget = max_budget.value;

标量子查询

1
2
3
4
5
6


select dept_name,
(select count(*)
from instructor
where department.dept_name = instructor.dept_name)
as num_instructors
from department;

having和group by

group by

1
2
3
4


-- 在group子句中的所有属性取值相同的元组将被分在一个组内,显然,当涉及的属性名越多,分的组也会越多
select dept_name, avg (salary)
from instructor
group by dept_name;

注意,没有出现在group by中的属性只能以聚集函数的参数形式在select语句中出现,如下方的例子中ID就是不该出现的属性,因为一个组中的教师可以有不同的ID,那就无法选定保留哪一个ID:

1
2
3
4


/* erroneous query */
select dept_name, ID, avg (salary)
from instructor
group by dept_name;

having: 作用于group的条件判断

1
2
3
4
5


select dept_name, avg (salary) as avg_salary
from instructor
group by dept_name
having avg (salary) > 42000;
-- 平均薪资低于42000的部门分组将被过滤掉

关系的集合

三种运算均自动去重

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


-- union(并集): 找到至少在一个关系中出现的被select选中的元组,自动去重
-- union all: 保留重复项
(select course_id
from section
where semester = 'Fall' and year= 2017)
union
(select course_id
from section
where semester = 'Spring' and year= 2018);
-- intersect(交集): 找到在两个关系中都出现的被select选中的元组,自动去重
-- intersect all: 保留重复项
(select course_id
from section
where semester = 'Fall' and year= 2017)
intersect
(select course_id
from section
where semester = 'Spring' and year= 2018);
-- except(差集): 找到在前一个关系中出现,但不在第二个关系中出现的,被select选中的元组,自动去重
-- except all: 保留重复项

排在最末尾的order by: 结果排序

1
2
3
4
5
6
7
8
9


-- 不写默认为升序asc
select name
from instructor
where dept_name = 'Physics'
order by name; -- 排序按字典序,首字母大的在后面
-- 先排第一个,同名再按第二个排
select *
from instructor
order by salary desc, name asc;

习题3.1

1
2
3


select title
from course
where credits = 3 and dept_name = 'Comp.Sci.'

1
2
3
4


select distinct ID
from instructor,teaches,student,takes
where instructor.name='Einstein' and instructor.ID = teaches.ID and student.ID =takes.ID and(takes.semester ,takes.sec_id,takes.year,teaches.course_id)=(teaches.semester ,teaches.sec_id,teaches.year,takes.course_id)
-- 写疯了

1
2


select max(salary)
from instructor

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


with max_salary(v) as (select max(salary) from instructor)
select ID,name
from instructor
where salary =max_salary(v)

-- 炫技写法1
select ID,name
from instructor
where salary >= all(select salary from instructor)

-- 2
select ID,name
from instructor 
where salary = (select max(salary)from instructor)

e 目标: 2017年秋季每个课程段选课人数 approach: section,takes

1
2
3
4


select count(ID),course_id,sec_id;
from section natural join takes
where year=2017 and semester='autumn'
group by coures_id,sec_id;

f target: max enrollment in Autumn 2009

1
2
3
4
5
6
7


with enrollment(counts) as (
 select count(ID)
 from section natural join takes
 where semester = 'Autumn' and year = 2009
 group by course_id, sec_id
)
select max(counts) from enrollment;

ch4

join

natural join: 自动去重的发散join

自动去重,多列匹配

1
2
3
4
5
6
7


select name, course id
from student, takes
where student.ID = takes.ID;

-- 两者作用相同,尽管from的结果不同,但select时没有选择ID列,所以看不出来区别
select name, course id
from student natural join takes;

join…using: 自动去重的定向join

using 只能用于等值连接,不能配合其他谓词使用

1
2


select name, title
from (student natural join takes) join course using (course id);

相当于一个仅比对所需列的natural join,更加安全

join…on: 不自动去重的定向join

1
2
3
4
5
6
7


select *
from student join takes on student.ID = takes.ID;

-- 等价
select *
from student, takes
where student.ID = takes.ID;

当然,on在大多数情况下都可以用where直接替换,但对于outer join来说,二者是有所不同的

outer join: 保留空值的发散join前缀

outer join本身不能直接使用,需要搭配on,natural或者using

当我们希望即便一边的ID有值,但另一边不存在这个ID时,也保留该行时,可以使用outer join.

有三种形式:

left outer join: 只保留左边关系中的元组
right outer join: 只保留右边关系中的元组
full outer join: 保留两边关系的元组

以left outer join为例子来说明:

The attributes of tuple r that are derived from the left-hand-side relation are ﬁlled in with the values from tuple t.
The remaining attributes of r are ﬁlled with null values.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


select ID
from student natural left outer join takes
where course id is null;



select *
from (select *
from student
where dept name = 'Comp. Sci.')
natural full outer join
(select *
from takes
where semester = 'Spring' and year = 2017);

Database Design Using the E-R Model

数据库的设计并不简单,所以我们需要一些好用的模型来组织数据库,比如这章涉及的E-R模型.

忽然发现前面的笔记中废话太多了,像我的小测复习这样精炼就已经可以了,能够轻松的获取所需的信息

The Entity-Relationship Model

entity: a “thing” or “object” in the real world that is distinguishable from all other objects.
- 实体是一个独一无二的个体
attribute: 实体通过一组属性来表示,每个实体在它的每个属性上都有一个值(value)
entity set: 共享部分属性的实体集合
relationship: 多个实体之间的关系
relationship set: 相同类型的联系集合

看这个图就很好理解了,单独的两个实体,如Crick和Tanaka之间的关系就是relationship,而实体集之间的映射关系就是relationship set

E-R图

entity set: 使用矩形来表示,分为两个部分,一部分是实体集的名称,一部分是实体集所有属性的名称
relationship set: 使用菱形来标识,通过线条连接到多个实体集
- relationship set的描述性属性用单矩形虚线连接
映射基数(mapping cardinality): 一个实体通过一个联系集关联的其他实体的数量,有以下四种:
- 一对一: 从联系集到两个实体集各画一个有向线段
- 一对多: “多方"使用无向线段连接,“一方"使用有向线段
- 多对一: 与一对多刚好相反
- 多对多: 两边都是无向线段

The participation of an entity set E in a relationship set R is said to be total if every entity in E must participate in at least one relationship in R. If it is possible that some entities in E do not participate in relationships in R, the participation of entity set E in relationship R is said to be partial.

使用双线来表示一个实体集在联系集中全部参与.

strong entity and weak entity

强实体 (Strong Entity)

强实体是自足的，它不依赖于数据库中任何其他实体的存在。

物理特征：拥有一个独立的主键 (Primary Key)。这个主键不包含任何其他实体的属性。
物理隐喻：像一个拥有独立身份证的“自然人”。
ER 图标识：矩形框。
例子：Student（学生）。每个学生都有唯一的 student_id，无论这个学生是否选课，他作为“学生”这个实体的物理记录在数据库中都是独立存在的。

弱实体 (Weak Entity)

弱实体是寄生的，它必须依赖于另一个实体（称为“标识实体”或“父实体”）才能获得物理意义上的唯一性。

物理特征：没有足够的属性来构成自己的主键。它的主键是物理借用来的，由“父实体的物理主键 + 自己的部分键（Discriminator/Partial Key）”共同组成。
物理隐喻：像“公寓里的房间”。没有公寓（父实体），“101室”这个编号物理上没有任何意义。
ER 图标识：双边矩形框。
例子：Section（开课班级）。单独看 sec_id（如 1 班）无法确定是哪门课。它必须物理依赖于 Course（课程），主键通常是 (course_id, sec_id, semester, year)。

概化与特化

特化 (Specialization) —— 自上而下

物理逻辑：将一个高层级的实体集（父类）根据特定特征，物理拆分为多个低层级的子实体集（子类）。
触发场景：当你发现某些属性只适用于部分成员，而不适用于全体时。
ER图表示: 由特化实体用空心箭头指向父类,如果一个实体可以属于多个特化实体集,则称为重叠特化(overlapping specialization),使用两个单独箭头;如果只能属于一个实体集,则称为不相交特化(disjoint specialization),使用一个箭头
物理示例：员工 (Employee) 实体。
- 只有“厨师”拥有 厨师等级 属性。
- 只有“司机”拥有 驾驶证号 属性。
- 物理动作：从 员工 集合中特化出 厨师 和 司机 子集。

概化 (Generalization) —— 自下而上

物理逻辑：提取多个实体集中的共同属性，物理归纳为一个更高层级的通用实体集（父类）。
触发场景：为了消除数据冗余，并在物理层面提供统一的访问接口。
物理示例：存在 老虎、狮子、大象 三个独立实体。
- 它们物理上共有 年龄、体重、所属区域 等属性。
- 物理动作：将它们概化为 动物 (Animal) 实体。

汇总

The Unified Modeling Language (UML)(待补充)

Relational Database Design(较难,待补充)

根据上一章的E-R图我们可以导出一组关系模式:

Complex Data Types

In this chapter, we discuss several non-atomic data types that are widely used,including semi-structured data, object-based data, textual data, and spatial data.

Semi-structured Data

Overview of Semi-structured Data Models

Flexible Schema

Some database systems allow each tuple to potentially have a diﬀerent set of attributes; such a representation is referred to as a wide column data representation. The set of attributes is not ﬁxed in such a representation; each tuple may have a diﬀerent set of attributes, and new attributes may be added as needed.

A more restricted form of this representation is to have a ﬁxed but very large number of attributes, with each tuple using only those attributes that it needs, leaving the rest with null values; such a representation is called a sparse column(稀疏表) representation.

Multivalued Data Types

Some representations allow attributes to store key-value maps, which store key-value pairs. A key-value map, often just called a map, is a set of (key, value) pairs, such that each key occurs in at most one element.

Nested Data Types

All of these data types represent a hierarchy of data types, and that structure leads to the use of the term nested data types.

JSON和XML是该数据库类型的最重要的两个代表

JSON(JavaScript Object Notation)

The JavaScript Object Notation (JSON), is a textual representation of complex data types that is widely used to transmit data between applications and to store complex data. JSON supports the primitive data types integer, real and string, as well as arrays, and “objects,” which are a collection of (attribute name, value) pairs.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


{
 "ID": "22222",
 "name": {
 "firstname: "Albert",
 "lastname: "Einstein"
 },
 "deptname": "Physics",
 "children": [
 {"firstname": "Hans", "lastname": "Einstein" },
 {"firstname": "Eduard", "lastname": "Einstein" }
 ]
}

XML(Extensible Markup Language)

The XML data representation adds tags enclosed in angle brackets, <>, to mark up information in a textual representation. Tags are used in pairs, with and delimiting the beginning and the end of the portion of the text to which the tag refers.

1
2
3
4
5
6


<course>
 <course_id> CS-101 </course_id>
 <title> Intro. to Computer Science </title>
 <dept_name> Comp. Sci. </dept_name>
 <credits> 4 </credits>
</course>

Object Orientation

Three approaches are used in practice for integrating object orientation with database systems:

Build an object-relational database system, which adds object-oriented features to a relational database system.
Automatically convert data from the native object-oriented type system of the programming language to a relational representation for storage, and vice versa for retrieval. Data conversion is speciﬁed using an object-relational mapping.
Build an object-oriented database system, that is, a database system that natively supports an object-oriented type system and allows direct access to data from an object-oriented programming language using the native type system of the language.

We provide a brief introduction to the ﬁrst two approaches in this section.

Object-Relational Database Systems

User-Defined Types

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


create type Person
(ID varchar(20) primary key,
name varchar(20),
address varchar(20))
ref from(ID);

create table people of Person;

-- We can create a new person as follows:

insert into people (ID, name, address) values
('12345', 'Srinivasan', '23 Coyote Run');

Type Inheritance

1
2
3
4


create type Student under Person
(degree varchar(20)) ;
create type Teacher under Person
(salary integer);

Table Inheritance

1
2
3
4
5
6
7


-- PostgreSQL
create table students
(degree varchar(20))
inherits people;
create table teachers
(salary integer)
inherits people;

Object-Relational Mapping(ORM)

A fringe beneﬁt of using an ORM is that any of a number of databases can be used to store data, with exactly the same high-level code. ORMs hide minor SQL diﬀerences between databases from the higher levels. Migration from one database to another is thus relatively straightforward when using an ORM, whereas SQL diﬀerences can make such migration signiﬁcantly harder if an application uses SQL to communicate with the database.

On the negative side, object-relational mapping systems can suﬀer from signiﬁcant performance ineﬃciencies for bulk database updates, as well as for complex queries that are written directly in the imperative language. It is possible to update the database directly, bypassing the object-relational mapping system, and to write complex queries directly in SQL in cases where such ineﬃciencies are discovered.

Textual Data

Textual data consists of unstructured text. The term information retrieval generally refers to the querying of unstructured textual data.

Keyword Queries

A keyword query retrieves documents whose set of keywords contains all the keywords in the query.

搜索引擎是information retrieval systems的典型例子,根据关键词返回网页内容.

Relevance Ranking

The set of all documents that contain the keywords in a query may be very large; in particular, there are billions of documents on the web, and most keyword queries on a web search engine ﬁnd hundreds of thousands of documents containing some or all of the keywords.

Information-retrieval systems therefore estimate relevance of documents to a query and return only highly ranked documents as answers.

Ranking Using TF-IDF

term: refers to a keyword occurring in a document, or given as part of a query.
TF: term frequency

One way of measuring TF(d, t), the relevance of a term t to a document d, is: where n(d) denotes the number of term occurrences in the document and n(d, t) denotes the number of occurrences of term t in the document d.

However, not all terms used as keywords are equal. Suppose a query uses two terms, one of which occurs frequently, such as “database”, and another that is less frequent, such as “Silberschatz”. A document containing “Silberschatz” but not “database” should be ranked higher than a document containing the term “database” but not “Silberschatz”.

To ﬁx this problem, weights are assigned to terms using the inverse document fre- quency (IDF), deﬁned as:

where n(t) denotes the number of documents (among those indexed by the system) that contain the term t. The relevance of a document d to a set of terms Q is then deﬁned as:

Almost all text documents (in English) contain words such as “and,” “or,” “a,” and so on, and hence these words are useless for querying purposes since their inverse doc- ument frequency is extremely low. Information-retrieval systems deﬁne a set of words, called stop words, containing 100 or so of the most common words, and ignore these words when indexing a document. Such words are not used as keywords, and they are discarded if present in the keywords supplied by the user.

这就是为什么输入python和爬虫得到的结果与python 爬虫相差无几的原因

Ranking Using Hyperlinks

Hyperlinks between documents can be used to decide on the overall importance of a document, independent of the keyword query; for example, documents linked from many other documents are considered more important.

Pagerank是该排序方法的著名代表之一

Spatial Data

Two types of spatial data are particularly important:

Geographic data: such as road maps, land-usage maps, topographic elevation maps, political maps showing boundaries.
Geometric data: include spatial information about how objects— such as buildings, cars, or aircraft— are constructed

游戏建模,谷歌地图都属于空间数据这一范畴

Application Development(过)

Big Data

当数据的数量和种类多到一定程度时,传统的关系型数据库就无能为力了,需要采用更为复杂的数据结构来处理.

The MapReduce Paradigm(待补充)

Data Analytics(过)

The term data analytics refers broadly to the processing of data to infer patterns, correlations, or models for prediction.

Physical Storage Systems

Overview of Physical Storage Media(物理存储介质概述)

高速缓存 (Cache)：速度最快且成本最高的存储形式。容量较小，由计算机系统硬件管理。数据库系统实现者在设计查询处理数据结构和算法时会关注高速缓存效应。
主存储器 (Main memory)：用于存放可被操作数据的存储介质，通用机器指令在主存上运行。主存容量在个人电脑上通常为几十 GB，大型服务器可达数百至数千 GB。主存具有易失性 (volatile)，电源故障或系统崩溃时内容会丢失。
闪存 (Flash memory)：与主存不同，闪存是非易失性 (non-volatile) 的。其单位字节成本低于主存，但高于磁带。
- 广泛用于照相机、手机和 USB 闪存盘。
- 固态硬盘 (Solid State Drive,SSD) 内部使用闪存存储数据，提供类似于磁碟的面向块的接口 (block-oriented interface)，典型块大小为 512 字节至 8 KB。
磁碟存储 (Magnetic-disk storage)：长期在线存储数据的主要介质，也称为硬盘驱动器 (Hard Disk Drive,HDD)。磁碟是非易失性的。访问磁碟数据时，系统必须先将数据从磁碟移至主存。虽然比 SSD 便宜，但在每秒支持的数据访问操作次数上性能较低。
- 俗称为机械硬盘
光存储 (Optical storage)：包括 DVD 和蓝光光盘，使用激光读写。虽然可用于存储备份，但不适合存储活动数据库数据，因为其访问时间远长于磁碟。存在只读、单次写入 (WORM) 和多次擦写版本。
磁带存储 (Tape storage)：主要用于备份和归档数据（如出于法律原因需长期安全存储的数据）。
- 磁带比磁盘便宜且可拆卸，但访问速度极慢，因为必须从头开始顺序访问 (sequential-access)。
- 磁碟和 SSD 被称为直接访问存储 (direct-access storage)。
- 常用于存储海量科学数据（可达 PB 级）或大型视频文件。

Storage Interfaces

接口标准

SATA (Serial ATA)：常用接口。SATA-3 版本理论带宽 6 Gbps，实际数据传输速率可达 600 MB/s。
SAS (Serial Attached SCSI)：通常仅用于服务器。SAS-3 版本支持 12 Gbps 的传输速率。
NVMe (Non-Volatile Memory Express)：专门为 SSD 优化的逻辑接口标准，通常运行在 PCIe 总线上。

存储网络架构

SAN (Storage Area Network)：
- 定义：通过高速网络将大量磁盘连接到多台服务器。
NAS (Network Attached Storage)：
- 定义：与 SAN 类似，但不对外呈现为裸磁盘，而是通过 NFS 或 CIFS 等网络文件系统协议提供文件系统接口。

云存储 (Cloud Storage)

特征：数据存储在云端，通过 API 访问。
限制：若数据未与数据库同地部署，延迟高达数十至数百毫秒，因此不适合作为数据库的基础存储。
应用：常用于存储对象（Object Storage）。

Data Storage Structures(过)

就算考了我也不会…

Indexing(索引)

Basic Concepts(基本概念)

使用索引可以在不深入查询数据库的情况下快速找到数据

有两种基本的索引类型:

顺序索引(ordered index): 基于值的顺序排序
哈希索引(hash index): 通过哈希函数映射

被索引标记的,用来查找记录的属性或属性集被称为搜索码(search key).

Ordered Indices(顺序索引)

The records in the indexed ﬁle may themselves be stored in some sorted order. A ﬁle may have several indices, on diﬀerent search keys. If the ﬁle containing the records is sequentially ordered, a clustering index is an index whose search key also deﬁnes the sequential order of the ﬁle.

Clustering indices are also called primary indices

Indices whose search key speciﬁes an order diﬀerent from the sequential order of the ﬁle are called nonclustering indices, or secondary indices.

也就是说,与文件顺序相同就是聚集索引,不同就是非聚集索引.

顺序索引的类别

顺序索引可以细分为两类:

稠密索引(dense index): 对于文件中的每个搜索码值都有一个索引项
稀疏索引(sparse index): 只为某些搜索码值建立索引项.

自然,稠密索引更容易定位一条记录,但稀疏索引占用的空间和维护开销更小.

索引更新

在以下两种情况下需要更新索引:插入和删除

插入

如果是稠密索引:
1. 如果插入项的搜索码值未出现在索引中,则插入一个新的索引项
2. 如果该搜索码值出现在索引中,则根据不同的索引结构来插入:
  1. 如果是每个索引项对应一个指针列表或一个桶的结构,那么就将该值指向该索引项的指针队列末端即可.
  2. 如果是索引项仅存储一个指针的结构,那么只需要把新纪录插入到该索引项对应记录的末端,不需要改动索引项
如果是稀疏索引(将记录分成块):
1. 如果新记录创建了新块,那么就需要插入一个新索引,选择该块中搜索键序号最小的键值作为索引键
2. 如果新记录插入到现有块中,并且键值比该块的所有记录都要小,那么就将旧键值替换成新的键值;否则不做任何改动

删除

如果是稠密索引:
1. 如果被删记录是该搜索码值的唯一记录, 则直接从索引中删除对应的索引项。
2. 如果该搜索码值在索引中仍有其他记录, 则根据索引结构处理:
  1. 如果是每个索引项对应一个指针列表或桶的结构, 则仅从该列表中删除指向被删记录的指针。
  2. 如果是索引项仅存储一个指针的结构（指向首条记录）:
    - 如果被删的是该键值的首条记录, 则更新索引项, 使其指向下一条具有相同键值的记录。
    - 如果被删的不是首条记录, 则无需改动索引项。
如果是稀疏索引 (以块为基准):
1. 如果索引中不存在该被删记录的搜索码值, 则无需对索引做任何改动。
2. 如果索引中存在该搜索码值, 则根据记录余留情况处理:
  1. 如果被删记录是该搜索码值的唯一记录:
    - 用数据文件中下一个出现的搜索码值替换当前的索引项。
    - 如果下一个搜索码值已经拥有索引项（即它已经是某块的块首）, 则直接删除当前索引项即可。
  2. 如果该键值仍有其他记录存在（即被删者是块首但不是唯一记录）:
    - 如果索引项正指向该被删记录, 则更新索引项, 使其指向该键值的下一条记录（新的块首）。

B+-Tree Index Files(待补充)

B+-Tree Extensions

Hash Indices(哈希索引)(过)

Multiple-Key Access(过)

Creation of Indices(创建索引)

1
2
3
4
5


-- 就某个关系的某个属性创建索引
create index <index-name> on <relation-name> (<attribute-list>);

-- 删除索引
drop index <index-name>;

例子

1

create index dept index on instructor (dept name);

Bitmap Indices(位图索引)

书上讲的特别烂,所以让AI写了一份:

为了透彻理解位图索引，我们直接通过一个教职员工数据表的完整流程来拆解。

1. 原始数据表 (Relation)

假设有 5 名员工，我们要对“性别”和“收入等级”建立位图索引：

记录编号 (ID)	姓名	性别 (Gender)	收入等级 (Income)
0	张三	男 (m)	L1
1	李四	女 (f)	L2
2	王五	女 (f)	L1
3	赵六	男 (m)	L4
4	孙七	女 (f)	L3

2. 索引的物理构造

系统会为每个属性的每一个可能取值生成一个位图。

性别属性 (Gender)

由于性别只有 m 和 f，产生两个位图：

性别=m 的位图：1 0 0 1 0（第0、3位是男，填1）
性别=f 的位图：0 1 1 0 1（第1、2、4位是女，填1）

收入等级属性 (Income)

收入等级有 L1, L2, L3, L4，产生四个位图：

L1 位图：1 0 1 0 0（记录0和2是L1）
L2 位图：0 1 0 0 0（记录1是L2）
L3 位图：0 0 0 0 1（记录4是L3）
L4 位图：0 0 0 1 0（记录3是L4）

3. 为什么它在多条件查询时极快？

假设我们要找：“收入等级为 L1 的男性”。 SQL 语句：SELECT * FROM table WHERE Gender='m' AND Income='L1';

数据库的操作步骤：

加载 Gender=m 的位图：1 0 0 1 0
加载 Income=L1 的位图：1 0 1 0 0
进行“与”运算 (AND)： $$ \begin{array}{r@{\quad}l} & 1 \ 0 \ 0 \ 1 \ 0 \\ \text{AND} & 1 \ 0 \ 1 \ 0 \ 0 \\ \hline & 1 \ 0 \ 0 \ 0 \ 0 \end{array} $$
读取结果：结果位图只有第 0 位是 1，系统直接去磁盘取 record 0 的数据。

4. 关键点总结：到底好在哪里？

对比 B+ 树：如果你用 B+ 树找“男性”，它会给你一堆指针列表；如果你再找“L1”，它又给你一堆指针。要把这两堆指针取交集，CPU 需要进行复杂的列表比对。而位图索引将这个问题简化成了计算机最擅长的位运算。
对比全表扫描：如果不建索引，数据库必须把每条记录的姓名、性别、收入等所有字段都读进内存再判断。而位图索引非常小，通常可以全部塞进内存，在不碰磁盘的情况下就已经把目标行号算出来了。
空间压缩：在实际工程中，如果数据量巨大，这些 000001 会经过特殊的压缩算法（如 WAH 压缩），占用的空间微乎其微。

5. 什么时候不能用？

如果一个属性的取值非常多（高基数），比如“身份证号”：

如果有 1 亿条记录，身份证号就有 1 亿种。
你需要建立 1 亿个位图，每个位图 1 亿比特。
结果：索引的大小会远超数据表本身，查询效率崩塌。

复习要点

仔细想想,中文班和英文班的卷子除了语言不同外应该没有什么区别,由于中英文版本教材的编排不同,所以只需要把内容更少的中文版教材搞定就行了!

全部的关系代数
全部的sql语法
索引

Query Processing(只要看1,2小节)(过)

Transactions

Transaction Concept

transaction: a unit of program execution that accesses and possibly updates various data items.

事务需要满足以下特性,这被称为ACID特性:

atomicity: 要么不执行要么全部执行,不存在中间状态
consistency: 保证数据库的属性,接口,完整性约束不变
isolation: 事务能够正常执行,不被并发执行的事务影响
durability: 即使事务执行时系统崩溃,该操作也不可撤销.

存储器分类

volatile storage: 易失性存储器,包括cache和main memory,存储的信息在系统崩溃后即丢失
non-volatile storage: 非易失性存储器,包括SSD,HDD和磁带等存储设备,尽管不会在系统崩溃时丢失数据,但是容易受到故障的影响导致信息丢失.
stable storage: 稳定存储器,将数据备份到多个非易失性存储器中

Transaction Atomicity and Durability

补充

Outline Of The Course

Chapter 1: Introduction
Chapter 2: Introduction to Relational Model
Chapter 3: Introduction to SQL
Chapter 4: Intermediate SQL
Chapter 5: Advanced SQL (只要求前三节)
Chapter 6: Entity-Relationship Model
Chapter 7: Relational Database Design
Chapter 8: Complex Data Types
Chapter 9: Application Design
Chapter 10: Big Data
Chapter 11: Data Analytics
Chapter 12: Physical Storage Systems (Sections 12.5 (RAID) omitted)
Chapter 13: Storage and File Structure
Chapter 14: Indexing and Hashing
Chapter 15: Query Processing (Section 15.1, 15.2)
Chapter 17: Transactions

斜体的为需要熟练的部分,黑体的为非常重要的部分

吐槽

教材详细过头了,而ppt基本是原封不动的搬运了整本书1300多页的内容,一个ppt最少五六十张,而总共有20多个ppt. 要说他敬业呢,ppt上的内容破碎无比,速览一遍发现不如看书完整,要说他不敬业呢,好歹有这么大的工作量.

(3/26)这本书真的是又臭又长…
(3/28)我服了原来这个ppt是官网上的,而我们老师实际啥都没干…

本教材核心: 大学数据库

keys used
schema diagram

关系表解析

 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
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115


create table classroom
	(building		varchar(15),
	 room_number		varchar(7),
	 capacity		numeric(4,0),
	 primary key (building, room_number)
	);

create table department
	(dept_name		varchar(20), 
	 building		varchar(15), 
	 budget		 numeric(12,2) check (budget > 0),
	 primary key (dept_name)
	);

create table course
	(course_id		varchar(8), 
	 title			varchar(50), 
	 dept_name		varchar(20),
	 credits		numeric(2,0) check (credits > 0),
	 primary key (course_id),
	 foreign key (dept_name) references department (dept_name)
		on delete set null
	);

create table instructor
	(ID			varchar(5), 
	 name			varchar(20) not null, 
	 dept_name		varchar(20), 
	 salary			numeric(8,2) check (salary > 29000),
	 primary key (ID),
	 foreign key (dept_name) references department (dept_name)
		on delete set null
	);

create table section
	(course_id		varchar(8), 
 sec_id			varchar(8),
	 semester		varchar(6)
		check (semester in ('Fall', 'Winter', 'Spring', 'Summer')), 
	 year			numeric(4,0) check (year > 1701 and year < 2100), 
	 building		varchar(15),
	 room_number		varchar(7),
	 time_slot_id		varchar(4),
	 primary key (course_id, sec_id, semester, year),
	 foreign key (course_id) references course (course_id)
		on delete cascade,
	 foreign key (building, room_number) references classroom (building, room_number)
		on delete set null
	);

create table teaches
	(ID			varchar(5), 
	 course_id		varchar(8),
	 sec_id			varchar(8), 
	 semester		varchar(6),
	 year			numeric(4,0),
	 primary key (ID, course_id, sec_id, semester, year),
	 foreign key (course_id, sec_id, semester, year) references section (course_id, sec_id, semester, year)
		on delete cascade,
	 foreign key (ID) references instructor (ID)
		on delete cascade
	);

create table student
	(ID			varchar(5), 
	 name			varchar(20) not null, 
	 dept_name		varchar(20), 
	 tot_cred		numeric(3,0) check (tot_cred >= 0),
	 primary key (ID),
	 foreign key (dept_name) references department (dept_name)
		on delete set null
	);

create table takes
	(ID			varchar(5), 
	 course_id		varchar(8),
	 sec_id			varchar(8), 
	 semester		varchar(6),
	 year			numeric(4,0),
	 grade		 varchar(2),
	 primary key (ID, course_id, sec_id, semester, year),
	 foreign key (course_id, sec_id, semester, year) references section (course_id, sec_id, semester, year)
		on delete cascade,
	 foreign key (ID) references student (ID)
		on delete cascade
	);

create table advisor
	(s_ID			varchar(5),
	 i_ID			varchar(5),
	 primary key (s_ID),
	 foreign key (i_ID) references instructor (ID)
		on delete set null,
	 foreign key (s_ID) references student (ID)
		on delete cascade
	);

create table time_slot
	(time_slot_id		varchar(4),
	 day			varchar(1),
	 start_hr		numeric(2) check (start_hr >= 0 and start_hr < 24),
	 start_min		numeric(2) check (start_min >= 0 and start_min < 60),
	 end_hr			numeric(2) check (end_hr >= 0 and end_hr < 24),
	 end_min		numeric(2) check (end_min >= 0 and end_min < 60),
	 primary key (time_slot_id, day, start_hr, start_min)
	);

create table prereq
	(course_id		varchar(8), 
	 prereq_id		varchar(8),
	 primary key (course_id, prereq_id),
	 foreign key (course_id) references course (course_id)
		on delete cascade,
	 foreign key (prereq_id) references course (course_id)
	);

departname: 部门的办公地点和预算
course: 培养计划中的课程
instructor: 教师的信息
section: 课表中的真实课程
- section是course在某一学期的映射
teaches: 教师教授的课程信息
student: 学生的信息
takes: 学生所选的真实课表

计算机网络笔记

Sat, 28 Feb 2026 08:00:00 +0000

教材:«计算机网络-自顶向下方法»
- (3/20): 不得不承认是一本神书,尽管部分地方所作的假设与计算过于枯燥和无用,但整本书还是很有体系足够全面的
- (4/3): 主干概念都讲的很明白,但边缘概念很多都讲的不明不白,不如不讲

应用层

应用层协议

http协议(2026/1/28)

事实上我把之前博客里写的内容直接搬过来了,比书上还是要详细不少的

概览

参考链接

HTTP 是一个客户端—服务器协议：请求由一个实体，即用户代理（user agent），或是一个可以代表它的代理方（proxy）发出。大多数情况下，这个用户代理都是一个 Web 浏览器，不过它也可能是任何东西，比如一个爬取网页来充实、维护搜索引擎索引的机器爬虫。

每个请求都会被发送到一个服务器，它会处理这个请求并提供一个称作响应的回复。在客户端与服务器之间，还有许许多多的被称为代理的实体，履行不同的作用，例如充当网关或缓存。

客户端发送的请求

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


POST /api/v1/user/update?id=1024 HTTP/1.1
Host: www.example.com
Content-Type: application/json
User-Agent: Mozilla/5.0
Authorization: Bearer eyJhbGci...
Content-Length: 45

{
 "nickname": "Apollo",
 "gender": "male"
}

POST: 客户端发起的请求所用方法
/api/v1/user/update?id=1024:服务器对应资源的路径和Query参数
Host: 目标服务器域名
Content-Type: 传输数据格式声明
User-Agent: 使用的浏览器代理
Authorization: cookie或token等身份识别头
Content-Length: 请求体字节长度
{"nickname": "Apollo","gender": "male"}: 传输的数据

服务端返回的报文

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


HTTP/1.1 200 OK
Date: Sat, 09 Oct 2010 14:28:02 GMT
Server: Apache
Last-Modified: Tue, 01 Dec 2009 20:18:22 GMT
ETag: "51142bc1-7449-479b075b2891b"
Accept-Ranges: bytes
Content-Length: 29769
Content-Type: text/html

<!DOCTYPE html>…（此处是所请求网页的内容）

METHOD

wiki

HTTP/1.1 协议中共定义了八种方法来以不同方式操作指定的资源,下面我列举常用的几种

GET

The request is for a representation of a resource.The server should only retrieve data; not modify state.

HEAD

The request is like a GET except that the response should not include the representation data in the body. HEAD = GET − Response Body

POST

The request is to process a resource in some way.

PUT

The request is to create or update a resource with the state in the request.

DELETE

The request is to delete a resource.

status code

In HTTP, you send a numeric status code of 3 digits as part of the response. These status codes have a name associated to recognize them, but the important part is the number.

In short: 100 - 199 are for “Information”. You rarely use them directly. Responses with these status codes cannot have a body. 200 - 299 are for “Successful” responses. These are the ones you would use the most. 200 is the default status code, which means everything was “OK”. Another example would be 201, “Created”. It is commonly used after creating a new record in the database. A special case is 204, “No Content”. This response is used when there is no content to return to the client, and so the response must not have a body. 300 - 399 are for “Redirection”. Responses with these status codes may or may not have a body, except for 304, “Not Modified”, which must not have one. 400 - 499 are for “Client error” responses. These are the second type you would probably use the most. An example is 404, for a “Not Found” response. For generic errors from the client, you can just use 400. 500 - 599 are for server errors. You almost never use them directly. When something goes wrong at some part in your application code, or server, it will automatically return one of these status codes.

User Agent

wiki 用户代理（user agent）在计算机科学中指的是代表用户行为的程序（软件代理程序）。例如，网页浏览器就是一个“帮助用户获取、渲染网页内容并与之交互”的用户代理

简单来说,user agent是http header里的客户端标识,告诉目标服务器自己是通过哪个浏览器进行访问的

爬虫总是需要伪装自己是通过某个代理访问服务器的,否则容易被拦截

一般格式

1

User-Agent: <product> / <product-version> <comment>

web浏览器的通用格式

1

User-Agent: Mozilla/5.0 (<system-information>) <platform> (<platform-details>) <extensions>

具体示例

1
2


Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.103 Safari/537.36
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36 Edg/91.0.864.59

MDN 服务器收到 HTTP 请求后，服务器可以在响应标头里面添加一个或多个 Set-Cookie 选项。浏览器收到响应后通常会保存下 Cookie，并将其放在 HTTP Cookie 标头内，向同一服务器发出请求时一起发送。你可以指定一个过期日期或者时间段之后，不能发送 cookie。你也可以对指定的域和路径设置额外的限制，以限制 cookie 发送的位置

Web cache

Web缓存是用于临时存储（缓存）Web文档（如HTML页面和图像），以减少服务器延迟的一种信息技术。Web缓存系统会保存下通过这套系统的文档的副本；如果满足某些条件，则可以由缓存满足后续请求

流程如下：

浏览器建立 TCP 连接 到 Web Cache，发送 HTTP 请求获取某个对象。
Web Cache 查询本地缓存。
- 若存在对象副本（cache hit），直接返回 HTTP 响应给浏览器。
若本地没有该对象（cache miss），Web Cache 建立 TCP 连接 到 Origin Server。
Web Cache 通过该 TCP 连接向 Origin Server 发送 HTTP 请求。
Origin Server 返回包含对象的 HTTP 响应。
Web Cache 接收响应后：
- 在本地缓存该对象副本
- 通过已有的 浏览器 ↔ Web Cache TCP 连接 将 HTTP 响应返回给浏览器。

从HTTP/1到HTTP/3

HTTP1采用非持续连接,每个HTTP请求都使用独立的TCP连接,可想而知慢的吓人因此,HTTP1.1采用了并行的TCP持续连接,共享带宽,但这会增加连接占用的带宽,容易引发网络阻塞这也是HTTP2推出的原因,只使用一个TCP持续连接来处理多个并行请求,将每个HTTP报文划分为帧单位,在第一个请求发送第一帧后,发送第二个请求的第一帧,以此类推,不断循环至于HTTP3,改进的程度比较有限,且基于UDP而非TCP连接,在22年已经标准化

SMTP协议(3/4)

SMTP,一种广泛使用,历史悠久的邮件传输协议,与HTTP一样使用的是持续的TCP连接流程如下:

Alice 在 用户代理（Mail User Agent） 中输入 Bob 的邮箱地址（如 bob@someschool.edu），编写邮件并发送。
用户代理将邮件发送到 Alice 的邮件服务器（Mail Server），邮件进入服务器的 邮件队列（message queue）。
Alice 邮件服务器上的 SMTP 客户端 从队列中发现该邮件，并建立 TCP 连接 到 Bob 的邮件服务器上的 SMTP 服务器。
完成 SMTP 握手 后，SMTP 客户端通过该 TCP 连接发送邮件内容。
Bob 的邮件服务器上的 SMTP 服务器 接收邮件，并将邮件存入 Bob 的邮箱（mailbox）。
Bob 在需要时启动 用户代理，从邮箱中读取邮件。

DNS

识别主机有两种方式———主机名(hostname)和 IP 地址。人们喜欢便于记忆的主机名标识方式,而路由器则喜欢定长的、有着层次结构的 IP 地址,因为hostname(如www.baidu.com)不能给路由器任何有关这个主机所在位置的信息

因此,我们需要一种能够将主机名转换成IP地址的服务,也就是域名系统（ Domain Name System ， DNS ）,由DNS服务器和DNS协议构成,运行在UDP之上,故也是应用层协议

常用查询方法

A 记录查询 (Address Record)
- 物理定义：将域名直接映射到一个具体的 IPv4 地址。
- 工作机制：当发起 A 记录查询时，DNS 服务器会返回一个由 4 组数字组成的物理地址（如 192.168.1.1）。
- 特性：它是最基础、速度最快的解析方式。浏览器拿到 A 记录后，可以直接根据该 IP 地址物理寻找目标服务器并建立 TCP 连接。
CNAME 记录查询 (Canonical Name Record)
- 物理定义：将一个域名指向另一个域名，而不是具体的 IP 地址。
- 工作机制：
  1. 客户端查询 www.example.com。
  2. DNS 返回一个 CNAME 记录（如 example.cdn.com）。
  3. 客户端必须针对这个新域名再次发起 DNS 查询，直到最终获得一个 A 记录（IP 地址）。
- 特性：
- 别名逻辑：常用于 CDN 加速或云服务。当后端物理服务器 IP 变动时，只需更改最终域名的 A 记录，所有指向它的 CNAME 无需修改。
- 性能成本：相比 A 记录，CNAME 至少会增加一轮 DNS 查询的物理往返时间。

阮一峰教程

为什么DNS用UDP 我们可以简单总结一下 DNS 的发展史，1987 年的 RFC1034 和 RFC1035 定义了最初版本的 DNS 协议，刚被设计出来的 DNS 就会同时使用 UDP 和 TCP 协议，对于绝大多数的 DNS 查询来说都会使用 UDP 数据报进行传输，TCP 协议只会在区域传输的场景中使用，其中 UDP 数据包只会传输最大 512 字节的数据，多余的会被截断；两年后发布的 RFC1123 预测了 DNS 记录中存储的数据会越来越多，同时也第一次显式的指出了发现 UDP 包被截断时应该通过 TCP 协议重试

实际应用举例

来看这样一个图,这是我在服务器上部署好了网站后,并在dynadot购买域名进入后台时将服务器的IP地址与对应域名绑定的过程.

使用A记录时,只要将服务器的ip地址填入就可以生效,但是别人访问这个服务器的时候只能在地址栏输入类似qin******.com的内容来访问. 但用户可能会输入www.qin******.com来访问这个服务器,但DNS并不会自动帮我将www前缀删除,所以我需要增加一条CNAME记录,将www.qin******.com指向qin******.com.

www前缀代表着这个网站使用的是http协议,是一个web网站,但由于现在基本都是web网站,少有类似ftp.qin*****.com这样的网站名了

P2P协议

BitTorrent是里面最为著名的代表,简单来说是一种多人之间互相传数据分包的协议,从而避免多人仅通过连接一台服务器导致的下载速度延缓. 磁力链接,torrent等资源链接都采用这一协议进行传输

DASH和CDN

DASH(Dynamic Adaptive Streaming over HTTP),将视频编码为不同清晰度的版本,根据用户的可用带宽来动态选择对应画质版本的视频

CDN(Content Distribution Network),由名字可以看出来,CDN相当于一个存储视频,文档等数据的分布式服务器,避免只用一个服务器来接受http请求导致的各种问题

Port(端口)

可以理解为通信接口,也就是说,应用层的进程通过特定的端口实现与运输层TCP/UDP的连接.

一个端口号使用16位无符号整数（unsigned integer）来表示，其范围介于0与65535之间
在TCP协议中，端口号0是被保留的，不可使用。1–1023 系统保留，只能由root用户使用。1024–4999 由客户端程序自由分配。5000–65535 由服务器端程序自由分配。在UDP协议中，来源端口号可选择是否填上，如果设为0，则代表无来源端口号。

运输层

Reliable Data Transfer Protocol (RDT)

显然书上这部分的引入太长了,而且并没有作者自以为的讲得很详细很清晰,还是让AI来总结一下吧可靠数据传输协议（Reliable Data Transfer Protocol，RDT）是计算机网络中用来保证发送方的数据能够完整、正确、按顺序送达接收方的一类协议。即使底层信道可能存在丢包、乱序或传输错误，RDT 也能通过设计机制让数据安全传输

1. RDT 的核心问题

在现实网络中，直接发送比特流存在很多潜在问题：

丢包：数据包在传输中可能完全丢失。
数据错误：信道噪声或硬件故障可能导致比特翻转，接收方收到的数据与发送方发送的数据不同。
重复数据：网络重传机制或路由问题可能导致同一个数据包被接收多次。
乱序：数据包可能通过不同路径传输，先发送的包晚到达。

可靠数据传输协议需要解决这些问题，保证端到端的可靠性。

2. 核心机制概览

RDT 的核心机制可以概括为五个部分：

分包（Segmentation）
- 将大数据拆分成较小的数据包，每个包称为 segment。
- 优点：小包更容易重传，减少重发的代价，同时便于序列号管理。
- 每个包通常包含以下内容：
  - 数据内容（payload）
  - 序列号（Sequence Number）
  - 校验和（Checksum）
错误检测（Error Detection）
- 利用 Checksum 或 CRC（Cyclic Redundancy Check） 检测数据在传输中是否被破坏。
- 发送方：计算数据包的校验和并附加在包头。
- 接收方：收到包后重新计算校验值，如果与包头的值相同，则认为数据正确，否则认为数据出错。
- 示例：
  1 2
  
  数据内容: 10110011 校验和: 0110
  接收方校验，如果不匹配，就触发重传。
序列号（Sequence Number）
- 每个数据包被赋予唯一的序列号（Sequence Number），用于：
  - 防止重复包处理
  - 保证接收顺序
- 序列号通常为 0、1 或更大的整数，循环使用。
- 接收方通过序列号判断是否收到新的包还是重复包。
确认机制（Acknowledgment, ACK / Negative Acknowledgment, NAK）
- ACK（确认）：接收方收到正确的数据包后发送 ACK 给发送方。
- NAK（否定确认）：接收方收到错误数据包时发送 NAK，要求发送方重发。
- 作用：
  - 让发送方知道哪些数据包成功到达。
  - 在丢包或错误情况下触发重传。
- 示例流程：
  1 2
  
  发送方 -> 数据包 1 -> 接收方接收方 -> ACK 1 -> 发送方
重传机制（Timeout & Retransmission）
- 发送方设置 超时时间（Timeout）。
- 如果在超时时间内没有收到 ACK，发送方会自动 重发数据包。
- 与 ACK/NAK 配合，可以保证即使网络丢包，最终数据仍然完整送达。
- 关键点：
  - 超时必须合理，否则可能导致过早重发或等待过久。
  - 与序列号结合，保证重发的数据仍能正确排序，不被重复处理。

3. 可靠数据传输模型示例

3.1 Stop-and-Wait RDT（最基础模型）

发送端：
1. 发送一个数据包，附带序列号。
2. 等待接收方发送 ACK。
3. 如果超时未收到 ACK，重发数据包。
4. 收到 ACK 后发送下一个包。
接收端：
1. 收到数据包，检查校验和。
2. 如果正确，处理数据并发送 ACK。
3. 如果错误或重复，丢弃数据或发送 NAK。
优点：简单易实现，理解方便。
缺点：效率低，因为发送方在等待 ACK 期间 无法发送下一个数据包。

3.2 Sliding Window RDT（滑动窗口机制,流水线机制）

改进 Stop-and-Wait，允许 发送方在等待 ACK 的同时发送多个包。
核心概念：
- 发送窗口：发送方未确认的数据包集合。
- 接收窗口：接收方能够接收的序列号范围。
优点：提高链路利用率，尤其是高延迟链路。
实现机制：
1. 发送方维护一个窗口，窗口内的包可以连续发送。
2. 接收方按序号接收，并发送 ACK。
3. 窗口滑动：收到 ACK 后，发送方窗口向前滑动，可以发送新的包。
常见变种：
- Go-Back-N：出错时从错误包开始重发之后所有包。
- Selective Repeat：只重发出错的包，更高效。

4. RDT 的工作流程总结

以最简单的 Stop-and-Wait 为例，端到端流程如下：

1
2
3


发送方: [数据包 seq=0] -------->
接收方: 检查校验 -> 正确 -> [ACK seq=0] -------->
发送方: 收到 ACK -> 发送下一个数据包 seq=1

异常情况：

数据包丢失：
- 发送方超时重发。
数据包出错：
- 接收方丢弃包并发送 NAK 或不发送 ACK。
ACK 丢失：
- 发送方超时重发数据包，接收方根据序列号判断重复，避免重复处理。

核心思想：发送方持续重发，接收方持续确认，直到每个包安全到达。

UDP(User Datagram Protocol)

UDP的原理非常简单,就是将src post传输的数据打包进UDP报文,并传递给网络层,再分发给dst post d

使用 UDP 时，在发送报文段之前,发送方和接收方的运输层实体之间没有握手.正因为如此，UDP 被称为无连接的.

为什么要用UDP

无连接状态。TCP 需要在端系统中维护连接状态。此连接状态包括接收和发送缓存、拥塞控制参数以及序号与确认号的参数。另一方面， UDP 不维护连接状态，也不跟踪这些参数。因此，当应用程序运行在 UDP 之上而不是运行在 TCP 上时，某些专门用于某种特定应用的服务器一般都能支持更多的活跃客户。
分组首部开销小。每个 TCP 报文段都有 20 字节的首部开销，而 UDP 仅有 8 字节的开销。
TCP 的拥塞控制会导致如因特网电话、视频会议之类的实时应用性能变得很差。由于这些原因，多媒体应用开发人员通常将这些应用运行在 UDP 之上而不是 TCP 之上

UDP包分析

一个完整的 UDP 包由 UDP 头部 + 数据负载（Payload）组成

UDP头部(固定8字节)

字段	字节数	说明
Source Port	2	源端口
Destination Port	2	目标端口
Length	2	UDP 头 + 数据总长度
Checksum	2	校验和，验证头部和数据是否损坏

1
2
3
4
5
6


0 15 16 31
+---------+---------+
| src port| dst port|
+---------+---------+
| length | checksum|
+---------+---------+

UDP 数据负载（Payload）

长度 = UDP Length – 8（头部大小）
完全由应用程序生成

UDP检验和

检验和用于确定当 UDP 报文段从源到达目的地移动时，其中的比特是否发生了改变（例如，由于链路中的噪声干扰或者存储在路由器中时引入问题）。发送方的 UDP 对报文段中的所有 16 比特字的和进行反码运算，求和时遇到的任何溢出都被回卷(把最高位进位送入最低位相加) 。得到的结果被放在 UDP 报文段中的检验和字段. 显然接收方可以再进行一次求和与反码相加,如果出现了0就说明数据有地方出错了.

TCP(Transmission Control Protocol)

TCP 被称为是面向连接的（ connection-oriented），这是因为在一个应用进程可以开始向另一个应用进程发送数据之前，这两个进程必须先相互 “ 握手 ”，即它们必须相互发送某些预备报文段，以建立确保数据传输的参数

TCP报文段分析

一个完整的 TCP 报文段由 **TCP头部（Header）+ 选项（Options，可选）+ 数据负载（Payload）**组成，其中最小 TCP 头部固定 20 字节。

TCP头部（最小20字节）

字段	字节数	说明
Source Port	2	源端口，标识发送应用进程
Destination Port	2	目标端口，标识接收应用进程
Sequence Number	4	序列号，标识第一个数据字节编号
Acknowledgment Number	4	确认号，期望收到的下一个字节编号（ACK置1有效）
Data Offset	4位	TCP头部长度（单位：32位字/4字节）
Reserved	3位	保留，必须置0
Flags（控制位）	9位	URG, ACK, PSH, RST, SYN, FIN 等
Window Size	2	接收端可接收缓冲区大小（流量控制）
Checksum	2	TCP头+数据+伪首部校验和
Urgent Pointer	2	紧急指针，URG置1时有效

TCP头部字段示意图

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


0 15 16 31
+-------------------+--------------------+
| Source Port | Destination Port |
+-------------------+--------------------+
| Sequence Number |
+---------------------------------------+
| Acknowledgment Number |
+----+---+---+--------------------------+
|Data|Res|Flags| Window Size |
|Offset| | | |
+----+---+---+--------------------------+
| Checksum | Urgent Pointer |
+-------------------+--------------------+
| Options (可选, 0~40 字节) |
+---------------------------------------+
| TCP Payload (数据) |
+---------------------------------------+

Flags（控制位）：
- URG：紧急指针有效
- ACK：确认号有效
- PSH：接收端应用立即读取数据
- RST：重置连接
- SYN：同步序列号，用于建立连接
- FIN：关闭连接
数据偏移（Data Offset）：
- 表示 TCP 头部长度，单位4字节
- 最小值 5（20字节），最大 15（60字节，包括选项）
窗口大小用于流量控制，控制发送端发送未确认的数据量。
校验和覆盖 TCP 头部、数据以及伪首部（IP源/目的地址、协议号、TCP长度）。

序号和确认号

报文段的序号（ sequence number for a segment ）是该报文段首字节的字节流编号

举例来说，假设主机 A 上的一个进程想通过一条 TCP 连接向主机 B 上的一个进程发送一个数据流。主机 A 中的 TCP 将隐式地对数据流中的每一个字节编号。假定数据流由一个包含 500 000 字节的文件组成，其 MSS 为 1000 字节，数据流的首字节编号是 0。则该 TCP 将为该数据流构建 500 个报文段。给第一个报文段分配序号 0 ，第二个报文段分配序号 1000 ，第三个报文段分配序号 2000，以此类推。每一个序号被填入到相应TCP报文段首部的序号字段中。

至于确认号,首先我们需要明确为什么需要确认号这样一个东西,由于TCP连接是双向的,故发送方也需要收到接收方传来的信息,故需要在确认号字段里填写缺失的来自接收方传来的包序号

假设主机 A 已收到一个来自主机 B 的包含字节 0 ～ 535 的报文段，以及另一个包含字节 900 ～ 1000 的报文段。由于某种原因，主机 A 还没有收到字节 536 ～ 899 的报文段。在这个例子中，主机 A 为了重新构建主机 B 的数据流，仍在等待字节 536 （和其后的字节）。因此， A 到 B 的下一个报文段将在确认号字段中包含 536

TCP连接的建立(三次握手)

第一步：SYN 报文段 客户端向服务器发送一个首部 SYN 比特置为 1 的特殊报文段。该报文不含应用层数据，但包含客户端随机选择的初始序号 client_isn。该报文段被封装在 IP 数据报中发送。
第二步：SYNACK 报文段 服务器接收到 SYN 后，为连接分配 TCP 缓存和变量，并回送允许连接的报文段。此时 SYN 比特置为 1，确认号字段设为 client_isn + 1，同时服务器选择自己的初始序号 server_isn。此报文段表明服务器同意建立连接。
第三步：ACK 报文段 客户端收到 SYNACK 后，也为连接分配缓存和变量，并向服务器发送最后的确认报文。此时 SYN 比特置为 0，确认号字段设为 server_isn + 1。该阶段的报文段负载可以开始携带实际的客户数据。

注意,第三步的时候客户端可以主动选择终止连接

拓展:为什么要三次握手想象一下这个场景，如果通信双方的通信次数只有两次，那么发送方一旦发出建立连接的请求之后它就没有办法撤回这一次请求，如果在网络状况复杂或者较差的网络中，发送方连续发送多次建立连接的请求，如果 TCP 建立连接只能通信两次，那么接收方只能选择接受或者拒绝发送方发起的请求，它并不清楚这一次请求是不是由于网络拥堵而早早过期的连接。

使用三次握手和 RST 控制消息将是否建立连接的最终控制权交给了发送方，因为只有发送方有足够的上下文来判断当前连接是否是错误的或者过期的，这也是 TCP 使用三次握手建立连接的最主要原因。

TCP连接的终止(四次挥手)

TCP 协议是对称的全双工协议，连接的任何一方（无论最初是客户端还是服务器）都可以主动调用 close() 发送 FIN 报文段来开启连接终止流程。在RFC 793中，通常将发起关闭的一方称为 Active Closer（主动关闭方），将接收关闭请求的一方称为 Passive Closer（被动关闭方）。

全双工:双方都可以同时发送和接收消息

主流程

主动方 (Active Closer) 发送 FIN 该方应用进程决定不再发送数据。TCP 实体构造首部 FIN 位为 1 的报文段。发送后，主动方进入 FIN-WAIT-1 状态。
被动方 (Passive Closer) 确认 ACK 被动方收到 FIN 后，由 TCP 协议栈自动回送 ACK。此时被动方进入 CLOSE-WAIT 状态，并通知上层应用进程对端已关闭。主动方收到 ACK 后进入 FIN-WAIT-2。
被动方 (Passive Closer) 发送 FIN 当被动方的应用进程处理完所有剩余数据后，显式关闭套接字。TCP 发送 FIN 位为 1 的报文段，被动方进入 LAST-ACK 状态。
主动方 (Active Closer) 发送最终 ACK 主动方收到对端的 FIN 后，发送最后一个 ACK，进入 TIME-WAIT 状态。被动方收到此 ACK 后直接进入 CLOSED 状态，释放所有资源。
主动方的资源释放延迟 主动方必须在 TIME-WAIT 状态维持 2MSL 时长，以确保最后一个 ACK 到达被动方，并清空网络中残存的旧报文段。倒计时结束后，主动方进入 CLOSED 并释放资源。

TCP中的可靠数据传输

为了实现可靠数据传输,TCP有以下三个机制: 超时间隔,冗余ACK和快速重传

首先,TCP设置一个初始超时间隔,发出某个包时开始计时,如果接收方未能在超时间隔内将ACK确认包传来,则标记为超时. 每当超时事件发生时,TCP重传具有最小序号的还未被确认的报文段。只是每次 TCP 重传时都会将下一次的超时间隔设为先前值的两倍.

接收方保存一个连续接收到的包末端序号,比如说,“已经收到了 100-200 和 300-400，但中间缺了 201-299”,那么末端序号就是201,尽管接收到了300-400的包,接收方仍会返回ACK=201,如果这次仍未收到201-299的包,则继续发送ACK=201,直到收到该部分的包为止,这被称为冗余ACK,之后,接收方立刻将序号调整为ACK=401.

如果发送方接收到对相同数据的3个ACK时,这说明之后的报文段已经丢失,那么发送方就执行快速重传,即重新发送之后的报文段.

换句话说,只收到两个ACK时不进行重传,原因如下:
- 如果包 A 比包 B 稍微晚了一点点到达（仅仅是走错了路或者在路由器队列里被插了队），接收方就会因为先收到 B 而发回一个重复 ACK。如果此时发送方立即重传，会导致网络中充斥着大量无谓的重传包，极大地浪费带宽。

因此,重传只在以下两种情况中发生:

超出超时间隔未收到该包对应的ACK时重传,这被称为超时重传
收到该包的三个重复ACK则立刻重传,这被称为快速重传

TCP流量控制

TCP 为它的应用程序提供了流量控制服务（ flow-control service ）以消除发送方使接收方缓存溢出的可能性. 为了实现流量控制,发送方维护一个接收窗口(receive window,rwnd),接收方为该TCP连接分配了一个接收缓存,并维护以下三个变量:

LastByteRead：应用进程从缓存读出的最后一个字节编号。
LastByteRcvd：放入接收缓存中的最后一个字节编号。
RcvBuffer：接收缓存的总大小。

为防止缓存溢出，必须满足： LastByteRcvd - LastByteRead ≤ RcvBuffer

那么接收窗口就需要根据缓存可用的空间来设置： rwnd = RcvBuffer - [ LastByteRcvd - LastByteRead ]

具体实现

通知机制：主机 B 将当前的 rwnd 值放入发给主机 A 的报文段“接收窗口”字段中。
发送方限制：主机 A 跟踪 LastByteSent（已发送编号）和 LastByteAcked（已确认编号）。
发送准则：主机 A 必须保证在连接生命周期内： LastByteSent - LastByteAcked ≤ rwnd

如果B的接收缓存已经存满,即 rwnd = 0 ,主机 B 随后清空缓存但没有数据回传，主机 A 将因无法获知新空间而被阻塞,因此当 rwnd = 0 时，主机 A 持续发送仅含一个字节数据的探测报文段,这些报文段会被确认，最终主机 B 的确认报文将包含非 0 的 rwnd 值，从而恢复传输。

拥塞控制原理(3/11)

由于实际应用中网络层总是不能实现具有无限容量的,无数据丢失的信道,故当数据传输量很大时信道很容易发生拥塞,故需要运输层使用拥塞控制方法来尽可能减小拥塞的可能. 在最为宽泛的级别上,我们可根据网络层是否为运输层拥塞控制提供了显式帮助,来区分拥塞控制方法。

端到端拥塞控制

在端到端拥塞控制方法中，网络层没有为运输层拥塞控制提供显式支持。即使网络中存在拥塞，端系统也必须通过对网络行为的观察（如分组丢失与时延）来推断之

网络辅助的拥塞控制

路由器会向发送方提供关于网络中拥塞状态的显式反馈信息

TCP拥塞控制

TCP 所采用的方法是让每一个发送方根据所感知到的网络拥塞程度来限制其能向连接发送流量的速率。如果一个 TCP 发送方感知从它到目的地之间的路径上没什么拥塞，则 TCP 发送方增加其发送速率；如果发送方感知沿着该路径有拥塞，则发送方就会降低其发送速率。

但是,这种方法提出了三个问题:

TCP 发送方如何限制它向其连接发送流量的速率呢？
TCP 发送方如何感知从它到目的地之间的路径上存在拥塞呢？
当发送方感知到端到端的拥塞时，采用何种算法来改变发送速率呢？

TCP发送方如何限制发送速率

如之前的TCP流量控制所说,TCP 连接的每一端都是由一个接收缓存,一个发送缓存和几个变量（ LastByteRead 、rwnd 等）组成。运行在发送方的 TCP 拥塞控制机制跟踪一个额外的变量,即拥塞窗口(congestion window,cwnd),它对一个 TCP 发送方能向网络中发送流量的速率进行了限制,即在一个发送方中未被确认的数据量不会超过 cwnd 与 rwnd 中的最小值.

LastByteSent -LastByteAcked≤ min{cwnd，rwnd}

因此,在接收窗口比较大的时候,通过调节cwnd的值,发送方可以调整发送数据的速率.

TCP发送方如何感知拥塞以及如何调整速率

至于如何感知发生了拥塞,TCP使用下列指导性原则：

丢失报文段意味着拥塞：当丢失报文段时，应当降低 TCP 发送方的速率。一个超时事件或四个确认（一个初始 ACK 和其后的三个冗余 ACK）被解释为“丢包事件”的隐含指示。TCP 发送方应当减小它的拥塞窗口长度，以应对这种推测的丢包事件。
确认报文段指示网络交付正常：当对先前未确认报文段的确认到达时，能够增加发送方的速率。确认的到达被认为是一切顺利的隐含指示，即报文段正成功交付，网络不拥塞。拥塞窗口长度因此能够增加。
带宽探测：TCP 调节其传输速率的策略是增加其速率以响应到达的 ACK，除非出现丢包事件，此时才减小传输速率。为探测拥塞开始出现的速率，TCP 发送方增加它的传输速率，从该速率后退，进而再次开始探测。网络中没有明确的拥塞状态信令，ACK 和丢包事件充当了隐式信号，每个 TCP 发送方根据异步于其他发送方的本地信息而行动。

完整的论述: TCP拥塞控制算法

该算法由三个阶段组成:

慢启动(Slow Start)
拥塞避免(Congestion Avoidance)
快速恢复(Fast Recovery) - 非必需

慢启动

cwnd的初始值通常都设置的很小,对于发送方而言,希望能够迅速找到可用带宽的大小.因此,cwnd的值以一个**MSS(最大报文长度)**开始,每当传输的报文段被确认就增加一个MSS,这样一来,每经过一个RTT(往返时间),发送速率就翻倍,以指数级别增长,如图所示:

如果丢包事件发生,发送方将会把cwnd值重新置为1,并设置一个新的变量ssthresh (slow start threshold)为cwnd/2-这里的cwnd值检测到丢包时的拥塞窗口大小,然后继续发送包. 当cwnd值增长到等于ssthresh时,发送方结束慢启动阶段,进入拥塞避免阶段

拥塞避免

该阶段中,每次传输后(即经过一个RTT后)将cwnd的值加一.

当再次触发丢包事件时,cwnd的值被再次置为1,ssthresh的值再次置为当前cwnd值的一半.

然而丢包事件有两个可能的触发机制:超时和收到3个冗余ACK. 对于后一种情况,既然能够收到接收方传来的ACK,这说明信道不是那么拥塞,因此,发送方只会将cwnd的值减半,并进入快速恢复阶段.

快速恢复

该阶段中,每当收到针对丢失报文冗余的ACK时,cwnd值加1 最终发送方收到对于丢失报文的ACK时,TCP降低cwnd后进入拥塞避免阶段;如果出现超时事件,则迁移到慢启动状态.

总览

TCP连接的公平性

如果在某一条有限带宽的链路上,不同的TCP连接的传输速率基本相同,则认为该拥塞控制算法是公平的.

在实践中,具有较小RTT的TCP连接能够在链路空闲时更快的占据带宽,从而享用更高的吞吐量;而由于UDP没有拥塞控制,所以需要专门抑制UDP的无限制增长来防止UDP占用所有带宽.

不管怎样,这个问题至今都没有很好的得到解决.

QUIC

QUIC,Quick UDP Internet Connections,与HTTPS同为应用层协议,但它使用UDP作为运输层协议,主要特征如下:

数据流: 允许不同的应用程序使用同一个QUIC连接
可靠传输: 尽管UDP是不可靠的,但我们可以让QUIC的应用层可靠,即加上数据检验和重传机制

网络层(3/12)

网络层用一句话来表示就是: 通过多个路由器将数据从服务端移动到客户端.为此,网络层需要具备以下两种功能:

转发: 当数据输入时,路由器需要将数据移动到适当的输出端口
路由选择: 网络层需要解决数据从服务端传输到客户端所采用的路径,相当于规划好了具体要用到的转发路由器

注意这里的端口是指物理的输入输出接口,与虚拟的软件端口不是一个概念.
网络层不具有重传机制,而是由上层协议来决定是否重传

这样来看的话,网络层便可以分为负责转发功能的数据平面和负责路由选择功能的控制平面.

数据平面

路由器工作原理

路由器有四个组件:

输入端口
交换结构: 将路由器的输入端口连接到输出端口
输出端口
路由选择处理器: 主要作用于交换结构

输入端口处理和基于目的地转发

输入端口可以通过转发表和嵌入式的搜索算法来查找传入的ip地址对应的输出端口,故可以在本地实现转发决策,而无需调用路由选择处理器.

交换方法

经内存交换

早期的路由器是传统的计算机,端口之间的交换.一个分组到达一个输入端口时，该端口会先通过中断方式向路由选择处理器发出信号。于是，该分组从输入端口处被复制到处理器内存中。路由选择处理器则从其首部提取目的地址，在转发表中查找适当的输出端口,并将该分组复制到输出端口的缓存中.

经总线交换

输入端口经一根共享总线将分组直接传送到输出端口,不需要路由选择处理器的干预.由于总线单一时间只能通过一个数据分组,故交换速率受到总线速率的限制.

经互联网络交换

克服单一、共享式总线带宽限制的一种方法是,使用一个更复杂的互联网络.如纵横式交换机使用由2N条总线构成的互联网络,能够并发转发多个分组,因此是非阻塞的

输出端口处理

输出端口处理取出已经存放在输出端口内存中的分组并将其发送到输出链路上

分组(packet):从传输层传入的打包好的数据帧

排队问题分析

在输入端口和输出端口处都可以形成分组队列，就像在环状交叉路的类比中我们讨论过的情况，即汽车可能等待在流量交叉点的入口和出口。排队的位置和程度（或者在输入端口排队，或者在输出端口排队）将取决于流量负载、交换结构的相对速率和线路速率。

我们现在更为详细地考虑这些队列，因为随着这些队列的增长，路由器的缓存空间最终将会耗尽，并且当无内存可用于存储到达的分组时将会出现丢包（packet loss）。回想前面的讨论，我们说过分组“在网络中丢失”或“被路由器丢弃”。正是在一台路由器的这些队列中，分组被实际丢弃或丢失。

为什么不加缓存空间?

我们很容易这样想：更多的缓存必定更好，因为更大的缓冲区能承受更大的分组到达率波动，从而降低路由器的丢包率。

但更大的缓冲区也意味着潜在的更长的排队时延。

对于游戏玩家和交互式电话会议用户，几十毫秒的时延就很关键。

如果为了减少丢包而把每跳路由器的缓冲区大小增加10倍，端到端时延可能随之增加10倍。

增加的RTT会使TCP发送方对拥塞或分组丢失的响应变慢：

TCP依赖RTT来估计超时重传定时器（RTO）。
RTT增大 → RTO变大 → 检测到丢包后等待更久才重传。
拥塞控制窗口增长更慢（慢启动、拥塞避免阶段受RTT影响）。
整体吞吐响应性下降，尤其在突发拥塞或间歇性丢包场景。

如何决定分组转发的优先权?

有以下几种调度方法

先进先出( First-In-First-Out，FIFO,也称为First-Come-First-Serve，FCFS)

调度规则按照分组到达输出链路队列的相同次序来选择分组在链路上传输

优先权排队(priority queuing)

针对不同分组或者IP地址配置不同优先级别的权限,每次转发分组时均从当前最高优先级别的队列中选择分组来传输,同一级别则采用FIFO方式

循环排队(round robin queuing discipline)和加权公平排队(Weighted Fair Queuing)

循环排队像优先权排队规则一样给不同分组分类,但是会轮流处理不同类,从而避免低优先级类难以被转发的情况. 加权公平排队会为不同类分配权重,保证在某一时刻下在排队队列中的某一类能够得到对应权重的转发量.

IPv4,IPv6,寻址(3/13)

IPv4数据报格式

网络层中的分组被称为数据报,IPv4数据报的格式如下:

版本:使用的IP协议版本,帮助路由器决定如何解释数据报的剩余部分
首部长度:用来确定载荷(运输层报文)实际开始的字节
服务类型: 可以将不同服务类型的数据报区别开来
数据报长度: 首部加上数据的总字节长度,为16bit,故理论最大长度为65535字节,但实际上很少超过1500字节
标识,标志,片偏移: 将一个大数据报分片为几个小数据报所需的字段
寿命: 确保数据报不会一直在网络中循环
协议: 指示数据部分是由哪个协议处理的,例如值为17表示要交给UDP处理
首部检验和: 检验是否有数据错误或丢失
源IP地址和目的IP地址
可选字段: 很少用
数据(有效载荷): 来自运输层

IPv4编址

一台主机通常只有一条链路连接到网络，当主机中的 IP 想发送一个数据报时，它就在该链路上发送。主机与物理链路之间的边界叫作接口(interface)

路由器与它的任意一条链路之间的边界也叫作接口,因此每台主机与路由器都能发送和接收IP数据报,为了明确源地址和目标地址,故每台主机和路由器接口都有自己的IP地址.

在IPv4协议中,一个IP地址长度为32字节,书写方法为点分十进制记法(dotted-decimal notation),即每个字节都用它的十进制形式书写,因此会有3个点,4个部分,每个部分占8字节,如:

193. 32. 216. 9 :11000001 00100000 11011000 00001001

互联这 3 个主机接口与 1 个路由器接口的网络形成一个子网(subnet),IP编址为这个子网分配一个地址223. 1. 1. 0 / 24,其中, /24被称为子网掩码,将地址的前24位设定为该子网的IP地址表示为255.255.255.0.需要时可以通过将子网掩码与ip地址取和得到子网地址;换句话说,只有前24位等于223.1.1的地址才属于这个子网.

可以在cmd输入ipconfig查看自己所属的子网.

IP地址是如何分配的(3/15)

IP 地址由因特网名字和编号分配机构(Internet Corporation for Assigned Names and Numbers,ICANN)管理,是非盈利的. 当某个组织获得了被分配的地址块后,可以为本组织内的主机与路由器接口逐个分配 IP 地址,这主要由动态主机配置协议 (Dynamic Host Configuration Protocol ， DHCP)完成.

某给定主机每次与网络连接时能得到一个相同的 IP 地址,或者被分配一个临时的 IP 地址. 除了主机 IP 地址分配外，DHCP 还允许一台主机得知它的子网掩码、它的第一跳路由器地址（也就是直连路由器,常称为默认网关）与它的本地 DNS 服务器的地址等其他信息.

网络地址转换(Network Address Translation,NAT)

NAT（网络地址转换） 是工作在路由器等网关设备上的物理逻辑，它允许整个局域网（LAN）内的成百上千台设备，通过同一个公网 IP 地址（WAN 端）访问互联网。

A. 出站请求 (SNAT - Source NAT)

当你的手机（192.168.1.5）访问网站时：

原始数据包：源 IP 是 192.168.1.5，源端口是 10001。
物理改写：路由器将源 IP 修改为自己的 公网 IP（如 1.2.3.4），并将源端口修改为一个新分配的端口（如 5000）。
记录映射：路由器在 NAT 表中记下一笔：5000 端口 <-> 192.168.1.5:10001。

B. 入站响应 (DNAT - Destination NAT)

当网站服务器回传数据时：

到达数据包：目标地址是 1.2.3.4:5000。
物理查询：路由器查找 NAT 表，发现 5000 端口对应的是内网的 192.168.1.5:10001。
物理还原：路由器将目标 IP 和端口还原，数据包准确送达手机。

IPv6

IPv6将地址长度从32bit增加到128bit,确保了IP地址不会被用完,具体结构如下:

版本: 4bit长,字段值为6
流量类型: 与IPv4的服务类型类似
流标签: 对数据流中的某些数据报给出优先权
有效载荷长度: 载荷的字节数量
下一个首部: 与IPv4中的协议字段含义一样,表示要交付给哪个运输层协议
跳限制: 类似于IPv4中的寿命字段,当跳限制计数变为0时,包被丢弃
源地址和目的地址
数据: 载荷

事实上,IPv6不再使用子网掩码,而是直接用一个整数表示网络部分的位数，写在地址后的斜线后,如: fe80::49e0/128

如何兼容IPv4

通过将IPv6数据报整个放入IPv4数据报的载荷部分中,并通过协议字段指示接收方这是一个装入了IPv6的IPv4数据报,从而实现了对网络层中使用IPv4路由器的兼容

补充: 泛化转发(4/22)

之所以叫泛化转发(Generalized Forwarding),是因为这里的转发除了网络层之外,还可能会涉及链路层,这与之前路由器的转发并不相同,因此加上泛化两个字来表示这个转发是宽泛而言的.

因此,泛化转发使用的设备也不是简单的使用链路层的交换机或者网络层的路由器,而是称为分组交换机

wiki 泛化转发主要基于OpenFlow标准来执行:

流表（Flow Table）

这是泛化转发的逻辑核心。每个分组交换机内部维护一个或多个流表。每个流表项（Flow Table Entry）由三个核心部分组成：

首部字段匹配值（Match）：这是“泛化”的具体体现。匹配字段可以涵盖 入端口、源/目的 MAC 地址、以太网类型、VLAN 标签、源/目的 IP 地址、协议号（TCP/UDP）以及源/目的端口号。这种跨 1-4 层的匹配能力，使得分组交换机既可以充当路由器，也可以充当交换机、防火墙或 NAT 设备。
计数器（Counter）：用于实时统计匹配该规则的分组数量、字节数等。这是流量监控与计费的物理基础。
操作（Actions）：当分组匹配成功后执行的动作，包括：
- 转发：发送到指定端口。
- 丢弃：执行安全过滤逻辑。
- 修改字段：例如修改 IP 头部（NAT 功能）或重写 MAC 地址（路由功能）。
- 入栈/出栈：针对 MPLS 或 VLAN 标签的封装处理。

匹配-动作（Match-plus-Action）抽象

与传统路由器“查找最长前缀-转发”的单一模式不同，泛化转发将其抽象为通用的“匹配-动作”范式。

机制本质：只要分组匹配首部字段（Match），就执行相应操作（Action）。这意味着网络管理员可以自定义非标准的处理流程。
流的概念：被相同规则处理的一系列分组被视为一个“流（Flow）”。网络管理的粒度从单纯的“路径选择”细化到了“流控制”。

控制与数据平面分离

OpenFlow 实现了物理上的解耦：

数据平面（Data Plane）：分组交换机只负责执行流表中的匹配逻辑，逻辑简单且支持硬件加速（通常基于 TCAM 内存）。
控制平面（Control Plane）：由远程控制器（Controller）统一管理。当交换机遇到无法识别的未知流时，会将其通过 OpenFlow 协议发送给控制器。控制器计算出处理规则后，再下发回交换机的流表中。

换句话说,数据在网络层中转发的时候,不再是简单的通过路由器后再经过交换机,而是直接通过分组交换机转发,从而大幅度减小了传播过程中出差错的概率.因此,泛化转发才是真正的转发,取代了我们之前所说的路由器转发.

中间盒(middlebox)

中间盒: 在源主机和目的主机之间的数据路径上,执行除了 IP 路由器的正常标准功能之外的其他功能的任何中间的盒子,可以提供以下三种功能服务:

NAT转换
安全服务: 如防火墙和电子邮件过滤器等
性能增强: 提供内容缓存等功能

控制平面

路由选择算法

按照集中式的还是分散式的来给算法分类:

集中式路由选择算法(centralized routing algorithm):也被称为链路状态(Link State,LS)算法,需要提前得知网络中每条链路的开销,从而计算出当前节点的最低开销路径
分散式路由选择算法(decentrlized routing algorithm): 每个节点仅有与其直接相连的节点链路开销,通过迭代和通信逐渐计算出最低开销路径,距离向量(Distance Vector)算法是一个代表.

链路状态(LS)算法

通过链路状态广播(link state broadcast)算法来获取整体的节点信息,并根据Dijkstra算法找到最佳路径. 但是,实际应用中会产生振荡(Oscillation)问题,也就是当路由恰巧都沿着最短路径转发时,这条路径的开销由于流量增大而不再是最优路径,因此路由都转向原本开销比较高但现在相对是开销最低的那条线路,又导致这条线路开销变高,路由又都回到原来的路由转发路径上,这样来回切换路径显然不利于网络减小时延.

距离向量(DV)算法

使用Bellman-Ford算法

因特网中自治系统内部的路由选择： OSPF

如果将网络看作一个大规模的路由器互联网络会遇到以下两个问题:

规模瓶颈（Scalability）：数亿台设备若运行单一路由算法，将导致内存耗尽、广播风暴以及算法（如距离向量）无法收敛。
管理自治（Administrative Autonomy）：不同 ISP 需要独立控制内部协议、隐藏拓扑结构，并按自身策略进行管理。因此,设计者将路由器规划成一个自治系统( Autonomous System,AS):
构成：处于相同管理控制下的路由器和链路集合。
标识：每个 AS 拥有全局唯一的 AS 号 (ASN)，由 ICANN 授权机构分配。
划分：ISP 可作为一个 AS，也可拆分为多个 AS。

光这样说还不够,看下面这个表格:

运营商	网络名称	AS 号 (ASN)	角色
中国电信	ChinaNet (163 骨干网)	AS4134	全球最大的 AS 之一，承载绝大多数宽带流量。
中国电信	CN2 (下一代承载网)	AS4809	独立的 AS，专注于高质量、低延迟的精品业务。
中国联通	中国联通骨干网	AS4837	原中国网通与联通合并后的核心 AS。
中国移动	中国移动骨干网	AS9808	移动宽带及移动端流量的核心承载 AS。

这样就很好理解了,当我们接入网络的时候,实际上是进入了某一个运营商的AS,而不是直接接入整个互联网.

在一个AS内部运行的路由选择算法称为(intra-autonomous system routing protocol).

开放最短路优先（ OSPF ）

该算法使用Dijkstra和周期性的路由广播,也就是说:

路由器向自治系统内所有其他路由器广播路由选择信息,而非只向相邻路由器广播. 每当一条链路的状态发生变化时(如开销的变化或连接 / 中断状态的变化)，路由器就会广播链路状态信息。即使链路状态未发生变化，它也要周期性地(至少每隔 30min一次)广播链路状态.从而能够运用Dijkstra得到正确的结果.

ISP之间的路由选择：BGP

前面讨论的是AS内部的路由选择,现在我们来考虑AS之间的路由选择,在internet中,所有AS运行相同的路由选择协议: 边界网关协议(Border Gateway Protocol,BGP).

BGP的作用

作为一种 AS 间的路由选择协议，BGP 为每台路由器提供了一种完成以下任务的手段：

从邻居 AS 获得前缀的可达性信息: 特别是，BGP 允许每个子网向因特网的其余部分通告它的存在。一个子网高声宣布 “我存在，我在这里”，而 BGP 确保在因特网中的所有 AS 知道该子网。如果没有 BGP 的话，每个子网将是隔离的孤岛，即它们孤独地存在，不为因特网其余部分所知和所达。
确定到该前缀的 “最好的” 路由: 一台路由器可能知道两条或更多条到特定前缀的不同路由。为了确定最好的路由，该路由器将本地运行一个 BGP 路由选择过程 (使用它经过相邻的路由器获得的前缀可达性信息)。该最好的路由将基于策略以及可达性信息来确定。

前缀指的是例如138.16.68/22这样的AS子网

通告BGP路由信息

一个AS中有两种类型的路由器:网关路由器(gateway router)和内部路由器(internal router),网关路由器直接与其他AS中的路由器相连接,内部路由器仅连接AS内部的主机和路由器

与先前AS内部的路由广播类似,网关路由器也会将对应的转发信息传递给相邻的网关路由和内部路由,从而找到不同AS之间的转发路由路径

找到最短路径(待补充)

IP任播(anycast)

路由选择策略

SDN控制平面

wiki

ICMP: 因特网控制报文协议

wiki 互联网控制消息协议（英语：Internet Control Message Protocol，缩写：ICMP）是互联网协议族的核心协议之一。它用于网际协议（IP）中发送控制消息，提供可能发生在通信环境中的各种问题反馈。通过这些信息，使管理者可以对所发生的问题作出诊断，然后采取适当的措施解决。

ICMP与传输协议（如TCP和UDP）显著不同：它一般不用于在两点间传输数据。它通常不由网络程序直接使用，除了 ping 和 traceroute 这两个特别的例子.

事实上,ICMP位于IPv4和IPv6报文里面,用于提供网络发生问题时返回报错信息

链路层

OVERVIEW

节点: 运行链路层协议的任何设备,包括主机,路由器,交换机,WiFi接入点
链路: 连接相邻节点的通信信道

链路层需要提供的服务

成帧(framing): 将网络层的数据报封装成链路层帧
协调多个节点之间的通信: MAC协议
可靠交付: 通过确认和重传确保数据不出错和丢失
差错检测

链路层是如何实现的

链路层控制器的大部分功能是在硬件中实现的,但也有部分链路层是在运行与主机CPU上的软件实现的.

差错检测和纠正

奇偶校验

假设要发送的信息D有d比特,在偶校验方案中,发送方附加一个校验比特,使得者d+1个比特中1的总数是偶数;在奇校验方案中则保证是奇数. 接收方只需要检测接收的d+1个比特中1的个数即可以验证是否出现差错,比如在偶校验方案中发现了奇数个1比特,则说明至少出现了1个比特差错. 但如果出现了偶数个比特的差错,那就无法检测出差错了.因此,可以采用二维的奇偶校验方案,通过行和列来检验从而减小没有检测到差错的概率

检验和方法

与TCP/UDP协议中采用的检验和类似.

循环冗余检测(Cyclic Redundancy Check,CRC)(待补充)

双方协商取一个最高位为1的r+1位多项式G,发送方在d位数据段D的后端附加r个附加比特R,使得这个d+r位数据在模2算术下可以被G整除,接收方只需要用G去除这个收到的数据就可以知道是否出现差错.

多路访问协议(multiple access protocol)

该协议的目标是实现多个发送和接收节点对同一个共享信道的访问.

因为所有的节点都能够传输帧,所以多个节点可能会同时传输帧,那么其他节点就会同时接收到多个帧,发生碰撞(collide),这时没有一个节点能够有效获得传输的帧.

在理想情况下，对于速率为 R bps 的广播信道，多路访问协议应该具有以下所希望的特性：

当仅有一个节点发送数据时，该节点具有 R bps 的吞吐量;
当有 M 个节点发送数据时，每个节点吞吐量为 R / M bps. 这不必要求 M 个节点中的每一个节点总是有 R / M 的瞬间速率，而是每个节点在一些适当定义的时间间隔内应该有 R / M 的平均传输速率;
协议是去中心化的; 这就是说不会因某主节点故障而使整个系统崩溃;
协议是简单的，使实现不昂贵.

信道划分协议(过)

随机接入协议(待补充)

在随机接入协议中，一个传输节点总是以信道的全部速率（即 R bps）进行发送. 当有碰撞时，涉及碰撞的每个节点反复地重发它的帧（也就是分组），到该帧无碰撞地通过为止. 但是当一个节点经历一次碰撞时，它不必立刻重发该帧. 相反，它在重发该帧之前等待一个随机时延. 涉及碰撞的每个节点独立地选择随机时延. 因为该随机时延是独立地选择的，所以下述现象是有可能的：这些节点之一所选择的时延充分小于其他碰撞节点的时延，并因此能够无碰撞地将它的帧在信道中发出.

Switched Local Area Networks

Link-Layer Addressing and Address Resolution Protocol(ARP)

MAC地址

A link-layer address is variously called a LAN address, a physical address, or a MAC address.

事实上,并不是主机或路由器具有链路层地址,而是它们的适配器(即网络接口)具有链路层地址

The MAC address is 6 bytes long, giving 2^48 possible MAC addresses. 尽管MAC地址是一个固定值并且是唯一的,但现在有可能用软件改变某个接口的MAC地址.

需要注意的是,一般来说一个设备的MAC地址总是不变的,而对应的IP地址总是根据连接到的网络而改变

一般来说,当源适配器要向向一个目的适配器发送帧时,它会讲目的适配器的MAC地址插入帧中,并将该帧发送到局域网中;有时候源适配器或者中途经过的交换机会将帧广播到所有的适配器. 当目的适配器接收到帧时,如果帧中的目的MAC地址与自己的MAC地址匹配,则会提取出封装的数据报并沿着协议栈向上传输;如果不匹配,则直接丢弃这个帧.

有时候源适配器需要让局域网的所有适配器接收并处理自己的帧,这个时候,可以在目的地址字段插入一个特殊的MAC广播地址,对于6字节MAC地址的局域网来说,广播地址是48个连续的1组成的字符串

Address Resolution Protocol,ARP(地址解析协议)

为了在发送链路层帧的时候指明接收该帧的适配器,需要提前知道适配器的MAC地址,从而实现包的正确发送,因此我们采用ARP协议来根据适配器对应路由器或主机的IP地址,找到其MAC地址

ARP: 将网络层地址与链路层地址相互转换的协议.它和DNS的作用基本类似,但一个重大区别是: DNS可以解析因特网上任意主机或者域名为IP地址,但ARP只为同一个子网的主机和路由器接口解析IP地址为MAC地址

ARP原理

每台主机或者路由器在内存中有一个ARP表(ARP table),包含了IP地址与MAC地址的映射关系,还有保存时限值,指示了从表中删除该映射的时间.

主机要发送帧前,先要发送一个ARP packet给自己的适配器,这个ARP分组包括发送和接收方的IP地址以及自己的MAC地址,指示适配器使用MAC广播地址发送这个分组并发送该链路层帧,从而让子网的所有适配器接收这个分组,IP地址与该ARP packet中包含的目的IP地址匹配的适配器会向发送方传回一个响应ARP packet,让发送方可以更新它的ARP表.

从这个角度来看,ARP与IP处于同一级别,都位于网络层

如何跨越子网传输数据

通过上面的论述,我们可以发现,ARP只适用于子网内部的转发,当我们要跨越子网转发数据时,应该先将数据转发给网关路由,再由网关路由来根据链路层帧包含的IP地址跳到下一个路由器,直到转发到目标主机的网关路由,再将数据交给目标主机

以太网(Ethernet)

以太网(Ethernet)几乎完全占据了有线局域网市场

以太网的帧结构

Data field (46 to 1,500 bytes): This field carries the IP datagram. The minimum size of the data field is 46 bytes.This means that if the IP datagram is less than 46 bytes, the data field has to be “stuffed” to fill it out to 46 bytes.
Destination address (6 bytes): This field contains the MAC address of the destination adapter.
Source address (6 bytes): This field contains the MAC address of the adapter that transmits the frame onto the LAN
Type field (2 bytes): 指示数据字段所用网络层协议的类型
Cyclic redundancy check (CRC) (4 bytes): 检测帧差错
Preamble (8 bytes): 用于唤醒适配器,告诉它现在有一个以太网帧来了

以太网的无连接传输

以太网技术向网络层提供不可靠服务. 具体来说, 当适配器 B 收到一个来自适配器 A 的帧, 它对该帧执行 CRC 校验, 但是当该帧通过 CRC 校验时它既不发送确认帧; 而当该帧没有通过 CRC 校验时它也不发送否定确认帧. 当某帧没有通过 CRC 校验, 适配器 B 只是丢弃该帧. 因此, 适配器 A 根本不知道它传输的帧是否到达了 B 并通过了 CRC 校验.

在链路层缺乏可靠传输有助于使以太网变得简单且便宜. 但是这也意味着传递到网络层的数据报流可能存在间隙.

如果由于丢弃了以太网帧而存在间隙, 主机 B 上的应用也会看见这个间隙吗? 正如我们在第 3 章中所学到的, 这完全取决于该应用是使用 UDP 还是 TCP.

如果应用使用的是 UDP, 则主机 B 中的应用确实会看到数据中的间隙.
另一方面, 如果应用使用的是 TCP, 则主机 B 中的 TCP 将不会确认包含在丢弃帧中的数据, 从而引起主机 A 的 TCP 重传.

注意到当 TCP 重传数据时, 数据最终将回到曾经丢弃它的以太网适配器. 因此, 从这种意义上来说, 以太网确实重传了数据, 尽管以太网本身并不知道它正在传输的是一个包含全新数据的全新数据报, 还是一个包含已经被传输过至少一次的数据的数据报.

链路层交换机(Link-Layer Switches)(待补充)

转发和过滤

Filtering is the switch function that determines whether a frame should be forwarded to some interface or should just be dropped. Forwarding is the switch function that determines the interfaces to which a frame should be directed, and then moves the frame to those interfaces.

假定目的地址为 DD-DD-DD-DD-DD-DD 的帧从交换机接口 x 到达,那么会有以下三种情况:

交换表中没有对应 DD-DD-DD-DD-DD-DD 的表项,则将这个帧广播到所有接口(除了接口x,因为帧是从接口x来的)
交换表中有对应 DD-DD-DD-DD-DD-DD 的表项,但是对应接口为x,那么显然你不可能把从接口x收到的帧再送回接口x,只能就地丢弃这个帧
交换表中有对应 DD-DD-DD-DD-DD-DD 的表项,对应接口不是x而是y,那么交换机就需要把这个帧送入接口y

疑问:第二种可能中,如果是局域网通信的话,那不就有可能用的是同一个接口吗?

在局域网（LAN）中，如果两个主机 A 和 B 都在“同一个接口”下，通常只有两种物理物理场景：

场景 A：接了集线器（Hub） 你将 A 和 B 都接在一个外接 Hub 上，再把 Hub 连到交换机的接口 $x$。
场景 B：共享介质（旧式同轴电缆） 所有主机物理上连在同一根线上。

交换机（Switch）的核心作用是隔离冲突域并跨端口转发。

当主机 A 发送一个目的 MAC 为 B 的帧进入接口 $x$ 时：

查表：交换机查找 MAC 地址表，发现 B 的 MAC 对应接口也是 $x$。
判断：交换机意识到，“目的地”和“来源地”都在同一个物理方向上。
结论：如果 A 和 B 都在接口 $x$ 下方，那么当 A 发出信号时，信号在到达交换机之前，物理上已经流经了 B（如果是 Hub 或共享总线）。

底层逻辑：交换机认为，既然目标 MAC 就在接收端口所在的网段内，那么目标主机 B 应该已经通过物理介质直接收到了这个帧。如果交换机再把它从接口 $x$ “弹回”去，不仅是浪费带宽，更会导致 B 收到两份重复的数据帧。

交换表的建立与交换机的自学习

交换表初始为空
对于在每个接口接收的帧,交换机会在表中记录以下信息:
1. 该帧的源MAC地址
2. 该帧是从哪个接口进来的
3. 当前时间
如果一段时间后,交换机没有接收到过与记录的源MAC地址相同的帧,那么就会在表中删除这个地址

那么,让我们来详细分析一个新产生的帧被目的MAC地址对应的交换机接收的过程:

当这个帧进入第一个交换机时,由于交换机不认识这个帧,故会在所有接口转发该帧并记录该帧信息
经过很多次转发,在传播路径上的交换机都记录了该帧的三种信息
当目的MAC地址对应的交换机接收到该帧时,由于目的MAC地址对应的服务器一定已经将自己的信息存在了该交换机中(思考一下是为什么),那么只需要将该帧送入服务器的适配器即可完成整个流程.

虚拟局域网(VLAN)

wiki
- 由于书上讲的不明不白,所以去额外找资料了

VLAN的工作原理是在广播域内转发的网络帧上添加标签，从而使网络流量看起来如同被分割在不同的网络中。这样即使在同一个物理网络，VLAN也能将网络隔离开来，而无需部署多套电缆和网络设备。

无线网络概览

前面谈的都是有线网络,现在来谈谈WiFi,4G等无线网络,它由以下三个要素组成:

无线主机: 可以是手机,电脑,家用电器,可以是移动的,也可以是位置固定不动的
无线链路: 主机通过无线链路连接到一个基站或者另一个主机
基站: 负责收发无线链路数据

我们可以把无线网络分为四类:

具有基站的单跳: 基站和主机之间可以直接通信,不需要经过中继节点,日常见到的无线网络如WiFi和4G都属于这一类型
无基站的单跳: 由一个主机进行收发无线数据,其他设备与该主机通信,而不通过基站,蓝牙协议便是典型的例子
具有基站的多跳: 主机与基站通信需要经过中继节点
无基站的多跳: 通过多个主机节点进行通信,这显然是最难设计的一类网络

无线链路的特征

与有线链路相比,无线链路有以下三个特点:

信号强度递减: 电磁波穿过物体时强度将减弱,也就是路径损耗
来自其他通信源的干扰: 同一频段的电磁波会相互干扰
多路径传播: 电磁波会经过地面或者物体反射,导致出现多径传播的问题显然,无线网络更容易出现差错,因此我们需要使用更为可靠的传输方法.

信噪比( Signal-to-Noise Ratio，SNR):单位为dB,是接收到的信号振幅与噪声幅度比值的以10为底的对数的20倍,显然,信噪比越大,信号就越干净.
比特差错率(BER): 接收方收到的一个比特为错误的概率

物理层的通信有以下特点:

使用同一个调制方法,SNR越高,BER越低: 因此发送方可以通过增加传输功率提高SNR来降低BER,但是这样会消耗更多的能量,并且当功率超过阈值时不再有实际增益
对于给定的SNR,调制方法的传输速度越高BER越高,这很容易理解,速度越快越容易出差错
对于给定的信道我们可以采用不同的调制技术

CDMA(待补充)

WiFi

尽管无线局域网(WLAN)的通信有很多技术可以选用,但是WiFi占据着统治地位. WiFi的正式名称为IEEE 802. 11 无线局域网

基本服务集 (BSS) 是WiFi的基本构件，有两个部分：

无线站点 (Station)：手机、笔记本等终端设备。
接入点 (Access Point,AP)：起中央基站作用的节点。

信道与关联

当管理员安装AP时,需要为AP分配一个服务集标识(Service Set Identifier,SSID)和一个信道号.

802.11运行在 2. 4GHz ～ 2. 485GHz的频段中,由11个部分重叠的信道组成, 当且仅当两个信道由 4 个或更多信道隔开时它们才无重叠,因此管理员需要指示AP的信道号避免影响到其他AP.

显然,当你进入咖啡馆时,你可以收到很多个AP传来的信号,那么我们是符合与一个特定AP连接的呢? 802.11协议要求每个AP周期性的发送信标帧,该帧包括该AP的SSID和MAC地址,供无线站点接收并处理;当然,主机也可以自己发送广播帧来主动扫描附近的AP,选定关联AP,具体过程如图所示: 选定与之关联的 AP 后，无线主机向该 AP 发送一个关联请求帧，并且该 AP 以一个关联响应帧进行响应。注意，对于主动扫描需要第二个请求 / 响应握手，因为一个对初始探测请求的帧进行响应的 AP 并不知道主机选择哪个（可能多个）响应的 AP 进行关联，这与 DHCP 客户能够从多个 DHCP 服务器中进行选择有诸多相同之处

与AP连接之后,主机便会发送DHCP报文获取自己的IP地址,从而与互联网连接.

802. 11采用的传输协议: CSMA/CA

802.11采用的MAC协议类型为随机接入协议,称为带碰撞避免的CSMA(CSMA with collision avoidance), 简称为CSMA/CA. 之所以802.11采用碰撞避免而非和以太网相同的碰撞检测,有以下两个原因:

检测碰撞需要主机同时具有发送信号和接收其他站点信号的能力,而802.11适配器接收到的信号强度往往远小于发送出去的信号强度
无线信号存在衰减,多路传播,隐藏终端等问题,无法检测到所有的碰撞

802.11的链路层确认方案

由于无线链路中的帧不能无损的到达目的地,因此802.11采用链路层确认方案来实现重传机制. 目的站点收到一个通过CRC校验的帧后,等待一小段时间-这被称为短帧间间隔(short inter-frame spacing),然后发回一个确认帧,如果发送站点在给定时间内没有收到确认帧,它就假定出现了错误并进行重传,如果若干次重传后仍未收到确认帧,则放弃发送并丢弃该帧.

为什么现代以太网不重传而802.11重传

因为802.11的环境极易丢包,如果依靠上层协议如TCP的重传机制,由于跨越了多层硬件,传输速率将会大幅度下降;而以太网线路的环境非常稳定,发生丢包的概率几乎为零,将少量的丢包问题交给上层协议处理可以减少不必要的设计复杂度.

CSMA/CA协议的详细原理

如果有一个帧要发送,发送站监听到信道空闲时,它等待一小段时间后发送该帧-这被称为分布式帧间间隔(distributed inter-frame space)
如果信道被占据,则站点选取一个随机回退值,在侦听到信道空闲时减小该值,信道繁忙时则保持该值不变
计数值减到零时,该站点发送帧并等待确认
如果收到确认,则帧被正确接收.如果要传输另一个帧,站点将从第二步重新开始;如果没收到确认,则站点进入第二步并在一个更大的范围内选取随机值

满格信号网速仍然很慢的原理

当大量主机使用同一个AP时,为了避免碰撞,单一主机的等待时间大量延长,从而导致了网速的降低;同时,AP的上行光纤容量有限,不允许所有设备以最大功率同时传输.

处理隐藏终端问题

尽管每个无线站点对AP都不隐藏,但两者彼此是隐藏的

当H1和H2要发送帧时,由于它们彼此是看不见的,因此都以为信道是空闲的,就会同时发送并导致碰撞.

为了避免碰撞,802.11通过让站点使用请求发送(Request to Send,RTS)控制帧和允许发送(Clear to Send,CTS)控制帧来预约何时访问信道. 发送方在发送帧之前,首先向AP发送一个RTS帧,指示自己传输帧和收到确认帧所需的总时间,AP收到该帧后广播一个CTS帧,指示发送方明确的发送许可并告知其他站点在这段时间内不要发送,从而避免碰撞.

这两个控制帧都很短,所以在这个过程中发生碰撞的可能性很小

尽管 RTS / CTS 交换有助于减少碰撞，但它同样引入了时延并消耗了信道资源。因此，RTS / CTS 交换仅仅用于为长数据帧预约信道。在实际中，每个无线站点可以设置一个 RTS门限值，仅当帧长超过门限值时，才使用 RTS / CTS 序列。对许多无线站点而言，默认的RTS 门限值大于最大帧长值，因此对所有发送的 DATA 帧，RTS / CTS 序列都被跳过。

802.11的帧结构

接下来对其中的重要组成部分做一点分析:

有效载荷与CRC字段
地址字段: 地址4仅在AP相互转发时使用,前三个字段的定义如下:
1. 地址1是要接收该帧的站点MAC地址
2. 地址2是传输该帧的站点MAC地址
3. 地址3是子网默认网关的MAC地址
序号,持续期,帧控制字段

无线站点在同一子网中的不同BSS之间移动

随着 H1 逐步远离 AP1 ，H1 检测到来自 AP1 的信号逐渐减弱并开始扫描一个更强的信号.H1 收到来自 AP2 的信标帧. H1然后与 AP1 解除关联,并与AP2 关联起来,同时保持其 IP 地址和维持正在进行的 TCP 会话.新AP2 会发送以太网广播,强制沿途交换机更新路径.

蓝牙

蓝牙网络运行在 2.4 GHz ISM（工业、科学、医学） 免授权频段。由于该频段同时被微波炉、车库门遥控器和无绳电话等多种设备占用，蓝牙在设计之初就将抗噪与抗干扰作为核心目标。

蓝牙的物理原理

时分复用（TDM）：蓝牙无线信道被划分为时长为 625 微秒 的时间隙。
频分跳频扩展频谱（FHSS）：在每个时间隙中，发送端在 79 个信道中的某一个进行传输。信道（频率）在每个时隙间按照已知但伪随机的规律切换。
抗干扰逻辑：通过跳频技术，即使 ISM 频段内存在其他设备的干扰，也只会影响到极少数特定时隙的蓝牙通信，从而保证了整体链路的稳健性。目前蓝牙数据速率最高可达 3 Mbps。

蓝牙网络的结构

在蓝牙网络（Piconet）中，设备角色分为以下三类：

主节点 (Master Device)：核心控制单元，负责管理连接数量、调度时隙以及控制所有连接设备的传输功率。
客户设备 (Client/Slave Device)：受控单元，遵循主节点的跳频序列进行通信。
存放设备 (Parked Device)：低功耗睡眠模式设备。它们保持与主节点的同步，但不参与数据传输，仅在需要时由主节点唤醒进入活跃状态。

主节点如何与其他设备连接

连接过程本质上是一个从“频率盲区”到“时间与频率双重同步”的过程，分为 查询（Inquiry） 和 寻呼（Paging） 两个阶段：

第一阶段：设备发现（查询）

广播探测：主节点在 32 个不同的信道上轮流发送询问消息，并将该序列重复传输多达 128 次，以确保覆盖所有可能的监听频率。
被动监听：潜在的客户设备在自己随机选择的频率上进行监听。
随机回退机制：一旦客户设备接收到查询，它会在 0 ~ 0.3 秒 之间选择一个随机时间量进行回退。这种“随机退避”设计是为了防止多个客户设备同时响应主节点而引发信号冲突。
身份响应：回退结束后，客户设备发送包含其唯一设备 ID 的报文响应主节点。

第二阶段：建立连接（寻呼）

定向寻呼：主节点在发现范围内所有潜在设备后，开始针对特定设备发送 32 条寻呼邀请报文。由于此时客户设备尚未获得跳频序列，主节点仍需在多个频率上重复发送。
确认握手：客户设备接收到寻呼报文后，返回 ACK（确认） 报文。
参数交付：主节点随后向客户设备发送关键配置信息，包括：
- 跳频序列模式（告知未来的频率路径）。
- 时钟同步信息（校准通信时间基准）。
- 活跃成员地址（分配逻辑地址）。
轮询激活：最后，主节点使用已同步的跳频模式对该客户设备进行轮询(polling)。一旦回复成功，双方正式进入连接状态，实现网络层面的握手。

更上层发生了什么

我们可以发现,蓝牙的链路层连接逻辑与其他的协议完全不同,这从而说明蓝牙的上层逻辑也与其他的协议不同,这里就不介绍了.

Cellular Networks: 4G and 5G

无线网络分为无线局域网和无线广域网,我们前面所说的WiFi和蓝牙就属于局域网,而这里的4G/5G就属于广域网了.

The term cellular(蜂窝) refers to the fact that the region covered by a cellular network is partitioned into a number of geographic coverage areas, known as cells. Each cell contains a base station that transmits signals to, and receives signals from, the mobile devices currently in its cell.

4G LTE Cellular Networks: Architecture and Elements

The 4G networks that are pervasive as of this writing in 2020 implement the 4G Long-Term Evolution standard, or more succinctly 4G LTE.

4G网络由以下几个部件构成:

Mobile device: 连接到蜂窝运营商网络的智能手机、平板电脑、笔记本电脑或物联网设备
1. 该移动设备还具有全球唯一的 64 位标识符，称为国际移动用户身份（ IMSI），存储在其 SIM （用户身份模块）卡上。IMSI 在全球蜂窝网络系统中识别用户，包括用户所属的国家和归属蜂窝网络。
Base Station: The base station is responsible for managing the wireless radio resources and the mobile devices with its coverage area.
1. 这类似于WiFi中的AP,但还有很多额外的功能
Home Subscriber Server (HSS): The HSS is a database, storing information about the mobile devices for which the HSS’s network is their home network.
Serving Gateway (S-GW), Packet Data Network Gateway (P-GW), and other network routers: 用于实现NAT,路由转发等功能
Mobility Management Entity (MME): 控制平面部件,用于验证设备,设置路径,追踪设备位置

无线链路对高层协议的影响

鉴于无线链路传播的比特差错率远高于有线链路,因此需要对上层协议如TCP连接做出针对性的处理

在所有情况下，TCP 的接收方到发送方的 ACK 都仅仅表明未能收到一个完整的报文段，发送方并不知道报文段是由于拥塞或切换，还是由于检测到比特错误而被丢弃的。在所有情况下，发送方的反应都一样，即重传该报文段 。 TCP 的拥塞控制响应在所有场合也是相同的，即 TCP 减小其拥塞窗口,这会导致带宽利用率骤降.

链路层重传 (LL-ARQ)

这是解决无线丢包的最前线。LTE、5G 或 Wi-Fi 协议在数据链路层（MAC/RLC 层）实现了快速重传。

机制： 基站与终端之间发现包序列不连续时，直接在二层进行重传，不向网络层汇报。
代价： 引入了抖动 (Jitter)，因为链路层重传会导致部分包延迟到达。

拥塞控制算法的进化 (BBR)

Google 提出的 BBR (Bottleneck Bandwidth and RTT) 算法改变了判断逻辑。

原理： BBR 不再将“丢包”作为减速信号。它通过周期性探测带宽极大值和延迟极小值来构建网络模型。
实战表现： 在一定比例（如 5% ~ 15%）的随机丢包环境下，BBR 能维持几乎满带宽的传输速率，而 CUBIC 则会因为不断减半窗口而彻底卡死。

选择性确认 (SACK)

原生 TCP 采用累积确认，丢一个包可能导致后续一连串包被重传。

机制： 启用 TCP_SACK 选项。接收端在 ACK 中告知发送端具体哪些数据块（Ranges）已收到。
效果： 发送端可以精确补齐缺失的数据，而不是盲目重传所有未确认的包。

拆分连接协议 (Split-TCP / Proxy)

在移动通信核心网中，常使用 PEP (Performance Enhancing Proxy)。

拓扑： 终端 <——无线链路——> 基站/边缘网关 <——有线主干——> 服务器。
机制： 将一个 TCP 连接拆分为两段。无线段使用针对高丢包优化的协议（如调整过初始窗口、禁用慢启动退避的私有协议），有线段保持标准 TCP。
逻辑： 避免了无线端的局部丢包反馈到远端服务器，缩短了重传的往返时间 (RTT)。

网络安全

网络通信中的安全需要满足以下要求:

机密性(confidentiality): 仅有发送方和希望的接收方能够理解传输报文的内容,这需要报文能够被加密和解密
完整性(message integrity): 通信内容在传输过程中不应该被篡改,这需要我们实现数据检验和可靠的传输通道
通信认证(end-point authentication): 发送方和接收方都需要能够证明另一方的身份是真实的
防御恶意攻击(operational security): 通过防火墙和入侵检测系统来防御网络攻击

密码学

我们现在假设A要向B发送一个报文,最初的文本被称为明文(plaintext),A使用密钥(key)m来加密明文,从而得到密文(ciphertext),并将其发送出去. B为了解密这个密文,需要使用密钥n来处理这个密文,从而得到明文.

显然,加密过程中最关键的就是密钥了,根据密钥是否对称(相同)可以将加密方式分为两种:

对称密钥系统: A和B所用的密钥是相同而且保密的,否则就没有任何意义了
非对称密钥系统(也称为公开密钥系统): 有两个密钥,一个是公开的密钥,称为公钥,所有人都可以获取;另一个是只有A或者B才知道的密钥

攻击手段

根据攻击者掌握的信息,大致有三种攻击手段:

密文攻击: 入侵者只截取到了密文,破解难度最高
已知明文攻击: 攻击者事先知道部分明文对应的密文
选择明文攻击: 攻击者能够选择任意一段明文并获取对应的密文,破解难度最低

对称密钥

Caesar Cipher(凯撒密码)

密钥为字母表偏移量,很容易被破解

Block Cipher(块密码)

TLS采用的就是这个加密方式将明文划分为固定长度k的块，通过一一对应的映射函数将其转换为相同长度的密文块.如果我们让k=3,就需要让000到111这8个输入转换到对应的三比特输出.

尽管当增大k值时转换表的破解难度大幅度上升,但交流的双方都需要维护一张2^k大小的转换表,这不太现实. 因此,块密码使用函数来模拟转换表,例如:当k=64时,我们可以把64比特块划成8个子块,每个8比特块按照一张独特的k=8的转换表处理,然后将转换后的64比特按照一定规则打乱后再分为8个子块进行处理,进行多次循环.这种算法的密钥是8张k-8的转换表.

如果用 1 秒破解 56 比特 DES 的计算机（就是说，每秒尝试所有 2^56个密钥）来破解一个 128 比特的 AES 密钥，要用大约 149 万亿年的时间才有可能成功

Cipher-Block Chaining: 引入随机性

前面的块密码有一个缺陷: 如果有多个块中的明文内容相同,如"HTTP/1.1"这类常见的前缀词,那么将会得到相同的密文,从而被攻击者探测到并进行破解. 因此,我们可以在加密时引入随机数,如下图所示: 这样一来,即使明文相同,得到的密文也会不同,而密文相同时,得到的明文可能相同,破解难度大幅上升.

同时,实际应用中不太可能一个个传输随机数,故块密码使用密码块链接(Cipher-Block Chaining,CBC)来高效传输接收方所需的随机数,基本方法如下:

在发送数据之前,发送方生成一个随机的k比特串(对应k比特块加密),称为初始向量(Initialization Vector,IV).表示为c(0),并以明文方式发给接收方
对第一个块，发送方计算 c(1) = Ks(m(1) ⊕ c(0))后发送密文
对于第 i 个块，发送方根据 c(i) = Ks(m(i) ⊕ c(i-1)) 生成第 i 个密文块

非对称密钥

该类型的密钥有三个关键要素:

一个公开的加密算法和一个公开的解密算法
一个公开的密钥,称为公钥
只有通信中的某一方才知道的密钥,称为私钥

使用非对称密钥的通信过程如下: 发送者用加密算法和公钥来加密报文,接收者使用解密算法和私钥来解密报文.

但是,这种加密方式有不少问题:

如何保证加密后的报文不会被破解?
由于任何人都可以通过公钥加密报文后发送给接收方,如何确定发送者是可靠的?

尽管有很多算法可以解决上述问题,但RSA算法已经成为了非对称密钥的代名词.

RSA算法

为了生成RSA的公钥和私钥,接收方需要执行以下步骤:

选择两个大素数p和q,值越大就越难破解.
计算n=pq和z=(p-1)(q-1)
选择小于n的一个数e,使得e和z互质.
选择一个数d,满足ed mod z = 1
那么接收方的公钥由(n,e)组成,私钥由(n,d)组成

通信过程如下:

发送方发送的报文以二进制形式表示为一个整数m,由于报文的位数有限,故m一般不会很大,在RSA算法中要求m < n,然后计算c = m^e mod n,从而得到密文c,并交给接收方.
为了解密c,接收方计算m = c^d mod n,得到报文m.

举一个简单的例子:

接收方选择p=5和q=7,得到n=35和z=24,在5,7,11等与24互质的数中选择一个数,比如说5,那么由于(5x29)-1可以被24整除(尽管5x5-1等取值也可以被24整除,但假设我们是随机取值取到了29),则d=29.
发送方使用(35,5)加密报文,接收方使用(35,29)报文.

会话密钥

由于大数据的指数运算非常耗时,所以实际应用中我们可以把对称密钥和RSA结合在一起,用RSA来加密对称密钥算法中所需的密钥.这个被加密的密钥称为会话密钥(session key)

RSA原理

RSA运用了两个数论中的结论,这里不做说明,我们只需要知道通过(n,e)和(n,d)就足够进行加密和解密,攻击者如果想暴力破解，唯一的方法是:

试图从公开的 n 中分解出两个原始质数 p 和 q。
只有得到 p 和 q，才能计算出z = (p-1)(q-1)。
通过ed ≡ 1 mod z 解出私钥 d。

RSA 的安全性依赖于这样的事实：目前没有已知的算法可以快速进行一个数的因数分解，这种情况下公开值 n 无法快速分解成素数 p 和 q。如果已知 p 和 q ，则给定公开值 e，就很容易计算出秘密密钥 d 。另一方面，不确定是否存在因数分解一个数的快速算法，从这种意义上来说，RSA 的安全性也不是确保的。

报文完整性的鉴别和数字签名

接收方验证某条消息是否可靠,需要检测以下两个因素:

该报文来自可靠的发送方
该报文在途中没有被篡改

加密哈希函数(cryptographic hash function)

hash function: 任意输入都会得到相同长度的输出
cryptographic hash function: 在哈希函数的基础上,需要额外保证: 找到一个不同的输入得到相同的输出是基本不可能的.

从加密哈希函数的定义就可以看出来,攻击者一般来说是无法用其他报文伪造原报文的,从而保证该报文不会被篡改.

常用的加密哈希函数有以下几种:

算法	哈希长度	基本逻辑	安全性现状与建议
MD5	128 位	将输入信息按 512 位分组，通过复杂的压缩函数进行多轮迭代处理，生成 128 位哈希值。	❌ 已破解，可人为制造碰撞。任何安全场景下都不应使用。
SHA-1	160 位	逻辑与 MD5 类似，哈希值更长（160 位），处理步骤更复杂，安全性有所提升。	⚠️ 已不足够安全，存在理论碰撞攻击，Google 等已在 2017 年实现碰撞。应避免使用。
SHA-2	224 / 256 / 384 / 512 位	采用 Merkle-Damgård 结构，更多轮次和更复杂的逻辑（如更多常量）。其中 SHA-256 和 SHA-512 最常用。	✅ 广泛认为安全，是替代 MD5 和 SHA-1 的首选标准。
SHA-3	224 / 256 / 384 / 512 位	采用全新的 Keccak 海绵函数结构，与 SHA-2 设计思路完全不同，提供更高的安全冗余。	✅ 安全性高，可作为 SHA-2 的备选方案。

报文鉴别: 使用哈希函数和鉴别密钥

使用哈希函数,我们可以这样验证报文的完整性:

Alice生成报文m并计算散列H(m).
然后Alice将H(m)附到报文m上,生成一个扩展报文(m, H(m)),并将该扩展报文发给Bob.
Bob接到一个扩展报文(m, h)并计算H(m). 如果H(m) = h,Bob得出结论:一切正常.

但这种方法有一个问题: 攻击者可以声称他就是Alice,并将报文发送给Bob,这显然可以通过报文完整性的验证.

因此,我们还需要加入鉴别密钥(authentication key),即一个被双方共享的秘密比特串,在下述过程中我们将其称为s.

Alice生成报文m,加入s生成m+s,并计算H(m+s),这被称为报文鉴别码(Message Authentication Code,MAC).
然后Alice将MAC附加到报文m上,生成扩展报文(m, H(m+s)),并将该扩展报文发送给Bob.
Bob接收到一个扩展报文(m,h),由于知道s,计算出报文鉴别码H(m+s).如果H(m+s)=h,Bob得出结论:一切正常.

数字签名

有时候,我们会需要用一个数字签名(digital signature)来标识某个文件,这个数字签名一定是独一无二,不可篡改的,这样才可以保证能够分辨出该文件的所有者.

一种方法是发送方使用某一加密哈希函数取得报文的hash值,并用私钥加密该hash值;而在验证这个签名时,接收方只需要用公钥去解密这个hash值,如果计算结果与该文件的hash值一致,则证明报文的来源可靠

公钥认证

要让公钥密码生效,必须要证明你使用的公钥来源可靠,比如A和B通信时,A需要证明报文中的公钥确实来自B.

因此,我们需要通过CA(certification authority)来将公钥与特定实体(一个人,一台路由器,一个网站等)绑定.

CA有以下两个作用:

证实一个实体的身份.这需要该CA能够执行严格的身份验证,具有权威性,常见的CA有"Let’s Encrypt",“DigiCert"等
将某个实体的身份与其公钥绑定为证书,由CA对这个证书进行数字签名

end-point authentication(端点鉴别)

前面的数字签名和公钥认证更像是被动被检测的,而这里提到的端点鉴别则是通信的某一方主动向另一方证明自己的身份.

应用层的安全服务: 安全电子邮件(过)

运输层的安全服务: TLS

TLS(Transport Layer Security)协议是由Netscape设计的安全协议-SSL(Secure Sockets Layer)协议-的升级版,所有的浏览器和服务器都支持该协议(看一下某个网站的URL,如果以https开始,就是启用了TLS),它有以下几个功能:

机密性: 攻击者可能截获购买者的订单并得到银行卡信息
完整性: 攻击者可能会修改购买者的订单地址或者购买数量
服务器鉴别: 证明这个网站是官方的,安全的

可以看到,TLS只在应用层进行了加密而已,并没有深入运输层

TLS Intro

先大致描述一下TLS的简化版本(称为类TLS),它具有三个阶段: 握手,密钥生成和传输数据

现在以客户B与服务器A之间的通信来举例说明

握手

在建立TCP连接后,B向服务器A发送一个hello报文,A在响应报文中返回该服务器的证书,里面包含了它的公钥.

由于该证书被某个CA证实过,B知道了这个公钥真的来自A,然后B生成一个主密钥(MS)用于此次TLS会话,使用A的公钥加密MS生成加密的主密钥(EMS),再发给服务器A,A再用私钥解密该EMS得到MS.

如此依赖,双方都知道了这次会话的主密钥MS.

密钥生成

事实上,出于安全性的考量,通信双方都会使用MS生成4个密钥:

E_B: 从B发送到A时所用的加密密钥
M_B: 从B发送到A时所用的HMAC密钥(用于验证报文完整性)
E_A: 从A发送到B时所用的加密密钥
M_A: 从A发送到B时所用的HMAC密钥

传输数据

TLS breaks the data stream into records, appends an HMAC to each record for integrity checking, and then encrypts the record + HMAC. 比如说B要发送数据,它需要将数据流分割为一个个record,为每个record附上HMAC,然后使用M_B加密这个record+HMAC包后发送出去. 事实上,这个HMAC中海含有这次发送的record所属的序号,从而保证攻击者不会打乱record的顺序.

record的结构

Type字段: 判断这是握手报文还是传输数据的报文,也用于关闭TLS连接

对于TLS更为精确的描述

握手阶段

TLS不强制通信双方使用特定的加密算法,而是允许双方在TLS会话开始时就统一决定加密算法,真实的步骤如下:

客户发送它支持的密码算法的列表和它选取的不重数(在本次会话中不会第二次出现的数字)
服务器从列表中选择一个对称密钥算法,一种非对称密钥算法和一种HMAC算法,它把这些选择联通证书和另一个不重数发给服务器
客户验证证书后提取服务器的公钥,生成PMS(Pre-Master Secret),用公钥加密该PMS后发送给服务器.
客户和服务器根据PMS和各自的不重数得到上述的四种密钥.
双方发送一段用新生成的密钥加密过的握手信息摘要，用于验证双方计算出的密钥是否一致，以及握手过程是否被篡改

你可能想知道在步骤 1 和步骤 2 中存在**不重数（Nonce）**的原因。序号不足以防止报文段重放攻击吗？答案是肯定的，但它们并不只是防止“连接重放攻击”

假设 Trudy 嗅探了 Alice 和 Bob 之间的所有报文。第二天，Trudy 冒充 Bob 并向 Alice 发送正好是前一天 Bob 向 Alice 发送的相同的报文序列。

若未使用不重数：Alice 将以前一天发送的完全相同的序列报文进行响应。由于接收到的每个报文都能通过完整性检查，Alice 不会怀疑任何异常。如果 Alice 是一个电子商务服务器，她将认为 Bob 正在进行第二次相同的订购。
若使用不重数：Alice 将对每个 TCP 会话发送不同的不重数，使得两天的加密密钥完全不同。当 Alice 接收到 Trudy 重放的 TLS 记录时，由于密钥不匹配，该记录将无法通过完整性检查，假冒的事务便不会成功。

连接终止

如果仅通过TCP连接来终止TLS会话的话,攻击者可以通过截断攻击(truncation attack)来提前结束会话,也就是说他可以在会话中发送一个TCP FIN报文,从而让用户不能获取完整的信息.

因此,我们可以用最后一个record指示终止会话.

网络层的安全服务: IPsec(过)

补充: 有线网络的安全服务

有线网络不提供安全服务,因为链路通信是很难被攻击和篡改的,只需依靠上层的安全服务即可.

无线网络的安全服务(待补充)

防火墙和入侵检测系统(待补充)

总结

显然,有这么多的防护措施,普通的cracker是很难通过截获IP数据报的形式来进行攻击的,相反,通过恶意软件(病毒,木马等)可以很轻易的跨越多层封锁,进入最薄弱的环节-主机-中,但这部分就不是网络通信所能负责的范畴了.

ppt概念补充

Intro

OSI七层协议

事实上,OSI协议的前三层对应了本书中的应用层,后面的都是一一对应的

Modem v.s. Router

Modem (调制解调器) 的本质是信号转换器。由于计算机内部处理的是二进制数字信号（Binary stream），而广域网传输介质（如电话线、光纤）传输的是模拟信号（Sinusoidal waves），Modem 负责将数字信号调制为模拟信号发出，并将接收到的模拟信号解调回数字信号。如果家中只有一个上网设备且不需要防火墙等功能，理论上仅需 Modem 即可拨号上网。

Circuit Switching and Packet Switching

Circuit Switching (电路交换)

核心流程：

建立电路 (Establishment)：在发送数据前，必须先预留一条端到端的物理路径。
信息传输 (Transfer)：数据（模拟或数字）沿专用路径实时流动。
电路拆除 (Termination)：释放沿途占用的所有资源。

关键特性：

优势：由于资源独占，数据传输速率恒定、带宽有保障，且数据严格按序到达，对用户而言网络是“透明”的。
劣势：存在明显的拨号/建立延迟。资源利用率低，即便不传输数据，信道依然被占用，无法分配给其他用户。
复用方式：通常通过多路复用 (Multiplexing) 将物理链路划分为多个子信道

Packet Switching (分组交换)

核心流程：

分组化 (Packetization)：将长报文拆分为带有首部（源地址、目的地址、校验码）的小数据包。
存储转发 (Store-and-forward)：路由器必须接收完一个分组的所有比特后，才能开始向下一跳转发。

关键特性：

优势：
- 带宽利用率高：单个分组可以使用链路的全带宽，资源按需分配，支持更多用户接入。
- 应对突发流量 (Bursty Data)：互联网流量通常是爆发式的，分组交换通过路由器内的缓冲区 (Buffer) 吸收临时流量峰值。
劣势：资源竞争可能导致拥塞和丢包；路由算法复杂；分组可能乱序到达目的地。

核心对比总结

特性	电路交换 (Circuit)	分组交换 (Packet)
资源分配	预先静态分配（独占）	动态按需分配（共享）
延迟来源	建立连接延迟	存储转发延迟、排队延迟
性能表现	稳定、无抖动、带宽保证	可能拥塞、有抖动、高并发
典型应用	传统电话网 (PSTN)	现代计算机网络 (Internet)

物理层

outline

Bandwidth (带宽) and Data Rate
Modulation (调制) of a Signal (ASK, PSK, QPSK, QAM)
Medium and Transmission (传输)
Multiplexing (复用) (FDMA, TDMA, CDMA)

Bandwidth (带宽) and Data Rate

Bandwidth: 单位时间内从一个节点传送到另一个节点的数据量

奈奎斯特采样定理 (Nyquist Sampling Theorem)

核心物理含义 在进行模数转换（将连续信号变为数字点）时，如果模拟信号包含的最高频率为 $H$ Hz，那么每秒钟至少需要进行 $2H$ 次采样（即采样频率 $f_s \ge 2H$），才能通过这些采样点无失真地重建原始信号。这个最小值 $2H$ 被称为奈奎斯特速率。

采样频率与波形还原 为了识别一个周期的波形，数学上至少需要记录其一个波峰和一个波谷。如果采样率低于 $2H$，采样点分布太稀疏，捕捉到的数据点在还原时会连成一个错误的低频波形，这种现象称为混叠 (Aliasing)。

混叠 (Aliasing) 的直观理解 当采样频率不足时，高频信号会“伪装”成低频信号。

视觉现象：在电影（每秒 24 帧采样）中看到快速转动的车轮时，车轮似乎在缓慢倒转，这就是典型的视觉混叠。
音频后果：若采样率过低，录入的高音会变成诡异的低频杂音，且这种失真是永久性的，无法通过软件修复。

工程应用实例

CD 音质：人耳听觉上限约为 $20\text{kHz}$。根据定理，采样率必须大于 $40\text{kHz}$。CD 标准采用 $44.1\text{kHz}$，正是为了确保完全覆盖人耳带宽并留出滤过缓冲带。
通信带宽：在带通信号传输中，该定理限制了在给定频率范围内可以传输的最大符号速率，是数字通信设计的底层物理约束。

信道容量与编码定理 (Channel Capacity & Coding Theorems)

奈奎斯特准则 (Nyquist Theorem) —— 无噪声信道 在理想的、没有噪声的信道中，由于信号在传输时存在码间串扰（带宽限制了信号的变化速率），最大数据传输速率由带宽和信号电平数（量化等级）决定。

公式： $$R_{max} = 2 \times BW \times \log_2 V \text{ bps}$$
参数含义：
- $BW$：信道带宽（Hz）。
- $V$：信号的离散电平数（量化等级）。
物理本质：在无噪声情况下，理论上可以通过无限增加量化电平数 $V$ 来提升速率，但受限于实际硬件对电平分辨的精确度。

香农定理 (Shannon’s Theorem) —— 有噪声信道 在存在随机热噪声的实际信道中，由于噪声会掩盖信号的电平细节，最大可靠传输速率（信道容量）存在一个物理极限。

公式： $$C = BW \times \log_2 (1 + \frac{S}{N}) \text{ bps}$$
参数含义：
- $C$：信道容量，即该信道能实现的理论最大信息传输速率。
- $S/N$：信噪比（SNR），信号功率与噪声功率的比值。
物理本质：噪声决定了我们能区分的最小信号电平差。即使无限增加发送电平 $V$，如果电平差小于噪声强度 $N$，接收方也无法识别。因此，带宽和信噪比共同限定了信息交换的上限。

信噪比与分贝 (SNR in Decibels) 在工程实践中，信噪比通常跨越多个数量级，因此常使用对数单位分贝 (dB) 来表示。

分贝换算公式： $$SNR(dB) = 10 \times \log_{10} (\frac{S}{N})$$
典型值参考：
- 如果 $S/N = 10$，则 $SNR = 10\text{ dB}$。
- 如果 $S/N = 100$，则 $SNR = 20\text{ dB}$。
- 如果 $S/N = 2$（信号是噪声的两倍），则 $SNR \approx 3\text{ dB}$。

核心逻辑总结

奈奎斯特告诉我们：由于带宽限制，采样率有上限（不能跑太快，否则波形会糊）。
香农告诉我们：由于噪声存在，信息的精细度有上限（不能分太细，否则分不清信号和噪声）。
实际应用：在设计网络系统（如 5G 或 Wi-Fi）时，通常会同时计算这两个值，取其中的较小者作为实际物理层的理论瓶颈。

Modulation

专业名词(即使前面提过也会放在这里)

RTT: Round-Trip Time(往返时延)
MSS: Maximum Segment Size,TCP 报文段中负载的最大长度限制
adapter: 适配器,主机与特定网络连接的硬件接口,俗称网卡.
Internet: 是由无数个使用 TCP/IP 协议族相互连接的计算机网络，物理上通过路由器和交换机在全球范围内实现数据交换与资源共享的网际网路。
packet(分组): 在特定层传输的数据包,从应用层,运输层,网络层,到链路层,每经过一层增加一个头部修饰
MAC: Medium Access Control,介质访问控制协议
ISP: Internet Service Provider
NAT: Network Address Translation
WAN: Wide Area Network - 广域网
LAN: Local Area Network - 局域网
SDN: Software Defined Networking,通过软件管理路由转发
CIDR: Classless Inter-Domain Routing,无类别域间路由,是一个用于给用户分配IP地址的方法
CSMA: Carrier Sense Multiple Access,发送信号前先监听,从而判断是否要在这个时候发送信号
全双工(full-duplex): 可以同时接收和发送数据
半双工(half-duplex): 同一时刻要么接收,要么发送,不能同时进行

实战

URL解析

如何给一个新房联网

网站证书

到了国外如何上网

备案流程

知乎介绍

wiki 个人网站备案需要准备：1份网站负责人的身份证件彩色扫描件或复印件；负责人的半身彩色照片（带接入商名称背景）；网站所使用的独立域名注册证书复印件（加盖公章）；主办单位所在地的详细联系方式；填写《信息安全管理协议》；填写《真实性核验单》。

根据相关行政法规，所有在中国境内的互联网信息服务提供者都应完成备案登记手续方可开办，未按规定备案的不得开展服务。

2005年2月8日，原中华人民共和国信息产业部部长王绪东签发《非经营性互联网信息服务备案管理办法》，并于3月20日正式实施。该办法要求从事非经营性互联网信息服务的网站进行备案登记，否则将予以关站、罚款等处理。

根据《互联网信息服务管理办法》，提供非经营性互联网信息服务需办理备案，而办理备案的前提是使用中国境内服务商提供的内地机房IP

事实上,在中国内地，合规运行网站需要两个核心要素：域名实名认证和ICP备案。

后缀限制：并非所有域名后缀都能备案。只有在工信部正式批复的顶级域名列表中的后缀（如 .com, .cn, .net 等）才允许备案。如果你使用 .io, .ai 等部分未批复后缀，即便服务器在国内也无法通过备案。
注册商要求：办理 ICP 备案的域名，其注册商必须在中国内地经过许可。如果你的域名是在 Namecheap、GoDaddy 或 Google Domains 注册的，必须先将域名转入国内注册商（如万网、新网），才能提交备案申请。

(补充): 事实上,所有的备案都是通过第三方的,小程序上线需要通过微信开发者平台备案;网站上线需要通过阿里云,腾讯云备案… 平台初审(一般需要1-2个工作日)通过后,再由平台提交给工信部审核(时间范围不确定,但一般不短),审核通过后会发短信提醒你. 这还没完,当你通过备案后,需要再进行公安联网备案,并提交审核,一般为2-3个工作日.

瑟瑟发抖…

理财笔记

Wed, 25 Feb 2026 08:00:00 +0000

前提

既然工作就是为了挣钱,那么学会如何理财显然比找工作更为重要,在低利率的大环境下把钱存银行是不可能跑得过通胀的,只有找到合适的投资方法,才能在确保基本盘不大出血的前提下能够实现比较理想的盈利.

可是,到底要怎么投资呢?

概念理清

可惜的是,能够好好讲清楚什么是期货,股票的运作模式是怎样的,如何选基金的入门书太少了,充斥在市面上的只有诸如«穷爸爸富爸爸»这样的垃圾书,不过仔细想想也是,要是把如何致富的方法都告诉你了,那我还怎么赚钱. «半小时漫画经济学4»是我至今唯一能看的过去的入门书,别看内容少,但基本能够让小白大致了解到投资的各种途径以及对应的风险情况.

债券

普通人接触最多的债券应该就是国债了,相当于借钱给国家去投资,非常稳定,也就说明利润很低,基本和在银行存款的利息没什么差别

股票

股票原先是帮初创公司用来募集资金的(如果全国14亿人每人给我一元,那我不就成亿万富翁了),一般都是由大股东持有大部分股票,剩余的股票中再分出一小部分给散户来投资.

但初创公司也需要选择在哪家交易所上市,如果全都挤到一个交易所里进行交易那显然不利于企业良性竞争,以下是交易所的类型:

国内A股: 国内只有两家交易所,上交所(上海证券交易所)-金融能源板,大型国企板,深交所(深圳证券交易所)-创业板,科创板
港股: 香港联合交易所,内地投资者可以通过港股通代理商来投资,看了看好像要持仓50w以上😅
美股: 如NYSE等证券交易所,可以买入美国科技股,国内也需要走代理商

买入股票前需要先开户,然后选定自己看中的股票买入100或者其他份数的股票,一份股票的价格就是股票图上的价格. 注意事项

T+1规则(A股):买入当天不能卖出,次日可卖
手续费:印花税,佣金等按比例收取的费用,会随着你持有股票(持仓)的日期逐渐下降,当你买卖股票的差额过小时可能连手续费都交不满

股票说来简单做起来很难,也就四个字:低买高卖,因此是高风险投资的首选,但可操作性和运气成分太高了,莽夫也可能误打误撞碰到连续涨停,运气差了即便你机关算尽也不能及时止损.

期货

期货实际上就是一张合约,卖方要以约定的价格在给定期限来临时把合约上的相关产品卖给买方,刚发明出来的时候是为了方便买卖方进行现货交易的,但现在基本是用来炒的了,有两种方式来炒期货

做多: 简单说就是赌这个产品会涨,低买高卖
做空: 赌这个产品会跌,在期限来临时以当日价格买入,但卖方要以当时的约定价格卖出,也是低买高卖看上去就有风险对吧,谁说得清几个月后的事情是怎样的呢?同时,由于期货只需要冻结10%的保证金就可以持仓(买入后并持有期货),故有着相当大的杠杆,一旦价格波动过大导致保证金都不能弥补亏损,会被庄家强制平仓(以约定价格全款结算期货),想想都可怕,因此期货是勇敢者的游戏,不建议平民参与

基金

实际上就是找代理人帮你投资,分为两种情况

稳健型基金: 大部分买入国债等稳定性资产,少部分用来进行高风险投资,保证基本盘
风险型基金: 大部分进行高风险投资,少部分买入,事实上ETF(exchange-traded funds,交易型开放式指数基金)就属于这一类型,但它会根据诸如纳斯达克指数这样的指标进行投资,相对来说风险会低一点点.

实物

房地产,黄金等可以用来炒作的(稀缺?)资源,均为高端局,不建议平民参与

为什么普通人不适合投资实物黄金

财报阅读(4/8)

学会阅读财报是投资的首要技能,如果你连一个公司的好坏都判断不了,又怎么去投资这个公司呢.

去哪看财报

债券详解

基金详解

股票详解

交易规则

交易时间

周一至周五 (法定休假日除外)

上午9：30 –11：30
下午1：00 – 3：00

交易单位

股票的交易单位为“股”，100股＝1手，委托买入数量必须为100股或其整数倍

交易方法

我开户用的是东方财富,只看股票就行,里面的资讯基本都是垃圾,当然用同花顺app或者其他的也可以,建议下载雪球app来学习别人的经验切记创业板等高端局需要你在其他板块交易第一次之后两年才解封,所以建议先选一个价位稳定的股票交易一次,才可以在以后投资科创板.

入股创业板的准确要求: 二十天内平均持仓20w以上并且有两年投资经验
使用港股通的准确要求: 二十天内平均持仓50w以上

术语理解(3/4)

委托: 事实上买卖股票是一个双方的过程,买股票时你自己的定价和买入份数便是一份买入委托,卖股票时你自己的定价和卖出份数便是一份卖出委托,只有当买入委托的价格高于或等于卖出委托的价格时,交易才会成立,不然就会一直留存在系统上,俗称’挂单'.
涨停:内地独有的机制,A股的日涨跌幅一般限制在10%,也有一些会限制在20%, 一旦达到限额,当日成交价高于涨停价或者低于跌停价的订单都要到次日进行结算,从而保证了股市不会大规模动荡,也就说明A股的短线交易利润率不会特别离谱
熔断:如果指数跌幅超过阈值,将会暂停整个交易所内的交易
杠杆: 当你借入资金来买入比如10倍份额的股票,那么亏损和收益就会被放大十遍,类似于物理学中的杠杆原理,实现作用力的放大.因此需要有自知之明,不要轻易加杠杆
短线/长线: 长短指的是持仓时间,如果你T+1日或者T+2日就卖出,那肯定是短线交易;如果你持仓几个月,或者好几年,那就是长线交易.这两种方法各有各的利弊.
阻力位: 目标价格上涨时可能遇到的压力，即交易者认为卖方力量开始反超买方，从而价格难以继续上涨或从此回调下跌的价位
支撑位: 交易者认为买方力量开始反超卖方，从而止跌或反弹上涨的价位。

股票种类

概念股(来源):概念股是与业绩股相对而言的。业绩股需要有良好的业绩支撑。概念股则是依靠某一种题材比如资产重组概念，三通概念等支撑价格。中国概念股就是外资因为看好中国经济成长而对所有在海外上市的中国股票的称呼。也有称中国概念股是“就是为了使人相信其谎言而编造的一切谎言”。
蓝筹股:股票市场上，投资者把那些在其所属行业内占有重要支配性地位、业绩优良，成交活跃、红利优厚的大公司股票称为蓝筹股。“蓝筹”一词源于西方赌场。在西方赌场中，有二种颜色的筹码、其中蓝色筹码最为值钱，红色筹码次之，白色筹码最差。投资者把这些行话套用到股票上就有了这一称谓。
绩优股: 就是业绩优良公司的股票，但对于绩优股的定义国内外却有所不同。在我国，投资者衡量绩优股的主要指标是每股税后利润和净资产收益率。一般而言，每股税后利润在全体上市公司中处于中上地位，公司上市后净资产收益率连续三年显著超过10％的股票当属绩优股之列。绩优股具有较高的投资回报和投资价值。

交易界面详解(根据知乎文章撰写)

上方部分

贵州茅台：股票简称
600519：股票代码
1426.19: 股票现价
金额(65.65亿): 当日交易总金额
最高: 当日最高成交价
最低: 当日最低成交价
换手率: 当日的成交量/发行总股数×100%，是反映市场交投活跃程度最重要的技术指标之一
总手: 当日开盘到现在为止的总成交手数,一手等于一百股
总值: 以当前股价乘以总股本数计算出来的股票总价值
流值: 可以流通的股票市值(这里流值和总值相同说明所有股票都是流通的,全都抛出来赚钱了)
市盈率: 总市值/预估全年净利润,一般在10-20之间比较好,太低的要么是被过于低估,要么是流动性太低;太高的,比如说贵州茅台,都是热门的,饱受炒作的股票

看得出来持仓茅台的都是精英中的精英(毕竟一千多一股呢,动辄就几百万了),不会轻易出手,一次交易的手数一般都比较少,股价波动非常缓慢

中间部分

五档:包含卖盘、买盘等候栏,该栏中卖一、卖二、卖三依次等候卖出。按照价格优先，时间优先的原则，谁卖出的报价低谁就排在前面，而这一切由电脑自动计算。卖一后面的数字为价格，再后面的数字为股票手数;该栏中买一、买二、买三表示依次等候买进，与卖出相反，谁买进的价格高谁就排在前面
现手: 最近的一笔交易手数
量比: 开市后每分钟平均成交量与过去5个交易日每分钟平均交易量的比值,表示交易的活跃度和投机性
委买: 还没有成交的买单
委买手数:当前所有个股委托买入前三档的手数总和。委托买入的手数比委托卖出的手数多，表示买比卖强，指数向上的概率比较大；委卖手数同理
外盘: 以卖出的报价成交叫外盘，俗称主动性买盘。当外盘累计数量比内盘大很多，而股价上涨时，表示很多人在抢着买进股票。如：外盘32721 内盘 29452，说明当日主动性抛盘远小于主动性买盘，形势对多方有利。
内盘：以买入的报价成交叫内盘，俗称主动性抛盘。当内盘累计数量比外盘累计数量大很多，而股价下跌时，表示很多人在卖出股票
流通股：上市公司股份中，可以在交易所流通的股份数量，按市场属性的不同可分为A股、B股、法人股和境外上市股。与流通股对应的，还有非流通股，非流通股股票主要是指暂时不能上市流通的国家股和法人股
自由流通股: 去除大股东后所剩的流通股

好文记录

zlib上搜索雪球专刊精选,总共有四本,里面的每一篇文章都很优质,建议小白在了解基本概念后就去看

但不要看太多,很多文章之间的观点都是相互矛盾的,并且到了最后你会发现讲的东西都差不多

投资体验

投资教学-爱吃鸡爪的阿辉

由于是雪球上的文章,不好转链接,文章又不是太长,故直接附录全文如下

 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


今天来讲讲小白投资第一课，主要最近有一些大学生刚刚接触到这个市场，问我从哪里入手，那我们就来讲讲对于小白来说，普通人常见的失误，这些失误要不去犯，再接下来就是讲讲我觉得小白如何完成第一桶金投资，并建立正确的投资理念，当然这些仅是我的观点，不一定正确，仅供参考，不构成任何投资建议。

1、首先要做的就是先把自己的账户激活，我国开通创业板和科创板需要两年的投资经验，翻译过来就是说，你需要在中登公司有一笔交易，并且这个交易要达两年，这个交易在任何一个券商做的买卖都是可以的。

中登公司的全名叫着中国证券登记结算有限公司，是一个政府机构，不是一家公司，我们所开立的上海股东户，深圳股东户，每人只能开三个，就是中登公司的上海股东户和深圳股东户只能开三个的要求。

要激活这个第一笔交易，买入ETF可不算哦，需要激活的是股票交易，比如花个800元买一手工商银行，明天再卖回掉，就算激活了，工商银行波动小，一天不会产生什么大的亏损，当然如果本是想要边炒股边学习，就没有必要做这个动作了，只要是买入任何一个股票，都会激活账户。

2、常见错误。

2.1 对于小白来说，正常不会入很多资金，一般来说，好公司股价都偏贵，大几十块钱，上百元，所以买一手就要大几千元上万元，对于小白来说，天然的第一个失误，会去买十块钱以下的个股，10元以下的个股，如果还是好公司，要么公共基施设施，要么高负债的公司。

但总的来说10元以下的个股，大概率都是不好的股票为主，这个是小白第一坑，认为5元涨一元就能涨20%，50元涨1元才涨2%，股市涨跌不是这么算的，是按比率算的，5元涨1元，和50元涨10元，都是20%，难度是一样的。而选择不好的低单价的公司，输的概率就特别的高，比历史的统计数据中，中位数选择20至50元之间单价的个股，很多品质很好，并且活跃性特别好。

2.2 小白的选股渠道这是所有亏损原因的重大原因，小白不会使用软件，不知道市场有多少个股票，分别是什么，只能接触到一个股票了解一个，几年时间，手中知道的股票也没有超过20多支，之所了了解到，是因为亲友推荐，或者新闻中看到，或者证券公司软件弹出来的信息。

为何是重大的亏损原因，是因为以上几个渠道得来的股票，全是热门股，并且都天花板极别的个股，很多已经是3至5倍涨幅的个股，有的甚至10倍涨幅的个股，最关键的时，这些个股，因为很热门，买进去，一般情况下还是能先赚钱的，接下来就是，不卖，这么贵，大回撤是必然，很容易亏大钱，如果卖了，因为自己不会使用软件选股，所以换另一个热门股，而热门股总有结束的时候，所以赚小钱，亏大钱，几乎是必然的。

2.3 浮盈加仓，一把亏光。对于小白来说，如果很幸运遇到一个相对不是很贵的好公司，刚开始做投资谁也没有勇气买很多，我第一笔入市资金才5万元，对于不了解的东西，我们有着天然的恐惧心理，所以会买一点点，然后看着它上涨，然后把它卖了，不过它继续涨就会更大仓位买回来，具体操作可能如下。

第一次，小金额，10元买入，11元卖出，赚钱了信心加持，第二次，中等金额，15元再次买入，17元卖出，两次的正确，信心暴棚，第三次20元大仓位买入，并且还向好朋友推荐，因为自己已成功在这个个股赚到钱，信心暴棚是很正常的，以为会一直持续，但是实际该个股开始买就10元，到现在翻倍，底部上来可能就3至5倍了，然后重大回撤，用小仓位来赚钱，用大仓位来亏钱。

2.4 高位亏损补仓，重仓套牢。对于小白来说，基本上不太可能买冷门股，也接触不到，能接触到的全是热门股，都是在天上飘的个股，这些股一旦发生回撤，下跌50%很正常，就像我们刚刚举的10元变成50元的股票，回撤50%变成25元，也是很贵很贵的，所以高位补仓，基本没有好的。

这个是所有小白中亏损最为严重的原因之一，因为大家都怕高，所以也在等，等到个股回撤了百分之十几，觉得机会了，高位进行补仓，要平摊自己的成本，等反弹保本，也就是10元涨到50元，被小白买入，然后跌到45元就觉得差不多了，然后补，又跌到40元，觉得跌太多了，又补，等跌到35元，觉得这是底了，再补，结果就是用月线一看，10元的股票，现在35元觉得是底，这个判断严重有误。

于是就出现了，亏损越跌越补，第一次补在山顶上，然后补在半山腰上，总结经验得出结论为：你想抄它的底，它想抄你的家，以为补在地板了，发现还有地下室，以来地下室了，发现还有十八层地狱。

对于越跌越补，只能是好公司很便宜的时候，才能使用这个方法，这个方法有很强的局限性，因为如何判断它是不是好公司，并且便不便宜，新手基本不可能做到，所以新手千万不要使用越跌越补，就是跌了，要么让它跌等反弹，要么就止损，不可以补仓。

2.5 卖出盈利，补仓亏损，最后自动单仓单票套牢。这个我早年常干的大蠢事，比如我买入股票A、B、C、D四支股票，如果A 涨了，盈利了我担心回撤，会把A卖掉，去补正在亏损的BCD，然后B也开始赚钱了，又卖掉去补还是亏损的CD，等C也反弹赚钱了，再次卖出去补还在亏损的D，最后本来布局了AB­CD四个票，结果就是三个上涨全部卖飞，留下了处于亏损的D，然后抱怨自己的运气不太好，而不反思自己有意为之把钱集中到亏禹的D中进行套牢。

对于这个方法，我一般都是分AB­CD买入，买入后不论涨跌，都不动，涨的让它涨，跌的让它跌，那最终赚钱和亏钱，就看自己当时买入这四家公司的价格贵不贵了，如果不贵，四家都赚钱，如果买的是中性的价格，账户还是赚钱的，如果全买贵了，账户亏钱。

因为买得便宜，四家全能暴涨，买得中性，下跌最多跌50%非常极致了，而上涨的个股中会出现翻倍或翻好几倍的，最终赚钱还是赚钱不错的，那全买贵了，很多贵的公司是真的品质很好，会更贵，或者很长时间留在贵的区域用业绩来夯实股价，比如像阳光电源，当时很贵，但也不跌，因为业绩增长慢慢的内在价值上升，股价从很贵变成贵，变成中性，后来继续上涨，当然其它很贵的下跌，但只要不动，也不一定会亏很多钱。

2.6 单仓单票，新手对市场认知不足，不能像老股民可以拿个五年十年，那么单仓单票，没有涨的话，实在是熬不过去，最后追涨杀跌，结果就是一直在换票的路上，不断卖飞，不断套牢止损，结果就亏钱很严重了。

3、该如何规划自己的投资生涯呢。

3.1 以学习为主，投资为辅，但是需要边操作边学习，人对自己无关事天然无法引发关注，如果没有注入适当的资金，基本上年轻人是不太可能学得会投资的，因为不关心也不关注，也没有输赢，学习天然要有输赢加持才会努力，比如在学校为了分数，那些不在乎分数的学生，就不会去关注老师上课说了什么。


就像我现在说找工作，第一要求，不管收入多少，必须交医社保，否则再高工资都不考虑，这句话对于不生病，又很年轻的大学生，肯定不会关心，只是听到，不会听进，但是你让45岁的中年人，没有医社保的工作，基本上不考虑，我们这个年龄会生病，也要考虑养老金，这句话还是这句话，但年轻人基本用不上医保，一年难得感冒一次，也不知道人生之跌的艰难，养老太遥远了。

3.2 站在前人的肩膀上去成功，资本市场是一个很棒的市场，不需要高智商，也不需要高学历，也不需要高人脉关系，你只要复制其它世界上顶级的投资大师的投资体系，不要自己创新，直接硬搬，虽然过程你可以质疑，但是可以边质疑，边坚持，必竟对方成功过，而你未成功的人的质疑，份量几何，所以在选择的时候，要主动选择成功的人的战略，自己的仅为参考，还着质疑一路坚持别人已成功的方法，不要太相信自己，要相信已功成名就的人的方法。

比如巴菲特的，好公司+安全边际+重仓长期持有。邓普顿和费雪的：成长型公司+分散仓位+盈亏都不去动。耶鲁大学基金会：分多种类+仓位平衡，每个板块使用市值恒定法，该板块上涨很多了，卖一些使得回到原来建仓时的市值，该板块下跌了，就补一些，补完后，仓位市值为建仓时的市值。再比如我国的公募基金投资圣经【好赛道，好公司，好价格】，公司好不好决定买不买，价格贵不贵决定买多少，翻译过来就是好公司才会进入目标，好公司价格太贵不买，好公司价格中性，就买一些，好公司价格便宜就买成重仓。

3.3 小白90%的损失来源于二手信息，10%来自于操作失误，操作是经验，是能力，是水平，后期慢慢学，二手信息可以直接变成一手信息，学会使用炒股软件，用炒股软件找公司，找信息，不使用朋友的信息，新闻的只言片语和断章取义。

更不使用券商弹出的个股，这些都是热门，赚钱效应很好的公司，券商才会弹出这些介绍信息，券商不会弹出一个好公司已经跌得一踏糊涂的标的，除非它想被骂，他只会弹出明天大概率有可能会赚钱的信息，但结果是，券商自营盘也不买这些，他们的自营盘也是做价值投资，要明白他们的自营盘可是不用交易佣金的哦，所以这些信息只会亏钱，不会赚钱的，要是会赚钱，他们自营盘就会买这些了。

4、我的方法介绍：买入便宜的好公司，熬个三五年。

4.1 公司足够好，这个公司要满足两个条件：1、这个公司的生意是不是好到，我想把它整个公司买下来，如果是，那我就会选择买它的股票，成为它的股东。2、这个公司如果没有上市，我是不是也会因为它是一个很棒的生意，成为它的股东，如果是，我才会买入成为它的股东。

4.2 好公司很便宜的时候开始买，越跌越买，很少考虑止损，好公司越便宜，越想收集它的筹码，可以无限收集它的筹码，但是考虑到资金有限，也考虑资金的效率，所以单个公司设上限，并且同时设单个板块上限。

比如我喜欢A公司，我设的单个板块为1000万元，那么我在越跌越买时，如果这个公司加这个板块的其它公司合起来买了1000万元后，我就不再打算投入了，再跌就看着跌，也不会去补了，不去跨越这个设定上限，以防无意中把所有资金集中到这个板块或这个公司中。

4.3 资本市场最终是把没有耐心人的钱转移到有耐心的人身上，无论你等不等得起三五年，最后你的人生都会迎来三五年，只是有的人三五年在几百家公司每家公司熬几天，最终也是在资本市场熬三五年，就像有的人三五年换很多工作，但还是工作了三五年，而我会在选定的一家公司上班三五年，也只是工作了三五年，一秒没有多熬，在哪当牛马不是牛马，换来换去，就不是牛马了吗？

4.4 反复做T，金顶战法，这个不做详细介绍，新手资金小，两个都不适用。

综上所述，核心就是，新手先学会炒股软件找公司找信息，不要到处听主播的，别人评论的二手信息，其次就是研究功成名就的人的方法，复制为主，复制是最容易成功的。最后少操作，多总结，多反思，三五年后，基本上就是别人十几二十年的功力了。

最后祝所有新手，小白，老股民2026年账户长虹。

以上仅为个人观点，不一定正确，仅供参考，不构成任何投资建议。

韭菜的自我修养

捕蛇者说博客

心得体会

炒股需要本金,工作优先投资(2026/3/13)

很多人都在吹港股和美股,但如果你跃跃欲试,想要注册港股通,点开链接一看,赫然写着:近20个交易日日均资产需不低于50万人民币,想要当韭菜也不给你机会.

所以,当你能一下梭哈的资金量连50w都填不满的时候,在庄家看来你远远算不上是一个交易对等方.

不妨认真想想,即便你买的股票侥幸遇到几个涨停,或者你通过所谓的量化交易成功押中了某支潜力股,如果你的持仓资金只有区区几百块钱,我想怎么看你赚不到多少钱.

因此,还是努力找份好工作吧,等积攒了一定的资金实力后再真正下场试试股票,而不是坐等手头的几百块变成几万块,试试撞大运穿越回去还现实一点.

股票不是投机

股票是拿100块赚10块的地方,不是拿100块赚1万的地方,如果真想发财,或许买彩票的概率还高一点.

股票不是投机而是投资,不能别人买你也买,别人卖你也卖,这注定了你永远在步别人的后尘,就算侥幸赚了一点很快就会亏完.

相反,应该在对一家公司经过细心的考察后,在自己认为股价合适的时候买入,在认为周期到头的时候卖出,才可以保证不会轻易被割韭菜.

如果你连买日常用品的时候也要货比三家,看看好评差评,那为什么到了股市这样一个中高风险的投资行业里不能去好好的评判一下某只股票的价值呢?

新手入门

事实上,我觉得新手最好的学习方法就是马上买入一支你觉得会涨的股票,不管是所谓的精确分析,量化处理,还是对上眼缘.

如果像我一样是普通人,当然买入一手单价小于10的股票就比较好,毕竟谁的钱是大风刮来的呢.

然后就开始了持仓环节,新手如果不是走狗屎运的话一般买入股票之后都会开始下跌,因为你了解的股票少,获得的资讯少,拥有的经验少,你不是韭菜谁是韭菜.

日复一日看着账面上刺眼的绿色,或许你很有耐力,愿意慢慢去熬到上涨的那天,最终回本;或许你等到头了股票也也没有回涨的时候;或许在抛售之后股票突然或者仍然上涨.无论怎样,你都完整的体验了一次投资股票的全过程.

我想,在这一段教训之后你一定会痛定思痛,决定在买入股票之前进行多方调研,在点击交易按钮之前反复斟酌.持仓之后在自己内心划定的价格区间内,即使看到绿字也能气定神闲,即使看到红字也能岿然不动

五档买卖法(3/8)

当资金量大的时候在几档买卖相隔的利润也很可观了,如果你划不准合理的价位,就建议在现在的第五档买入或卖出,从而赚上一点差价

长线or短线

短线交易意味着你需要在短短几日内持续不断的搜罗信息,找到次佳(散户很难找到最佳)的买入时机,并在恰当的时间卖出,基本这几天你别想做别的事情了.

而长线交易需要你在交易之前细致的考察意向公司的财务情况,分析未来的股价趋势,考察公司有无负面消息,然后在股价下跌到你的心理预期时买入,坐等升值(最好能升值).

一般来说,短线交易适合IPO(新股上市),舆论股,概念股,而长线交易适合慢牛股,蓝筹股,需要结合自己的考察选择合适的交易方式.

当然,如果你是学生的话,还是别搞短线交易了,总不能天天盯盘吧,搞长线交易才是普通人在A股赚钱的王道.

不正常的A股(4/15)

由于我一般不看港股和美股,故这里只分析A股.

A股有两大特性:

散户多,投机性强
劣质股票多,容易被套牢

由于A股的历史相对于美股来说短的可怜,因此极不成熟.同时,大多数股票投资者根本不会投资,只是跟风投资,因此一支股票只有三种走势,小幅度上下波动,涨停,跌停.很少有走向正常的股票.

而且,A股里有很多业绩差的股票(很多国企的股票),如死猪一样躺在哪里,却从没有被强制退市.至于业绩良好的股票则被炒到几百上千一股的价位,一般人也根本消受不起.

因此,投资A股只不过是散户们在绝境中的最后挣扎而已,如果房产和土地无法自由买卖,外汇也不能自由处理,个体经营也举步维艰,而国债和存款的利率却逐年下跌,那不就只能去买点股票来试图挽回一点资产吗.

特性	Bind Mount (绑定挂载)	Volume (数据卷)
数据位置	宿主机任意路径	Docker 管理的特定目录 (`/var/lib/docker/volumes/`)
路径指定	必须是绝对路径 (如 `/opt/app/data`)	卷名 (如 `my-vol`)，隐式管理物理路径
可移植性	低。依赖宿主机特定的文件目录结构	高。不依赖物理路径，易于在不同环境迁移
性能	依赖宿主机文件系统原生性能	绕过 Storage Driver 层，具备原生 I/O 性能
适用场景	开发环境同步代码、挂载宿主机配置文件	生产环境数据库持久化、日志存储、多容器共享
备份与管理	手动定位宿主机路径进行备份	使用 `docker volume` 命令管理，备份需挂载容器操作
隔离性	宿主机进程可轻易修改，安全性较低	由 Docker 隔离，减少了被宿主机其他进程误删的风险

技术笔记 on Revival-of-hope

算法笔记

数据结构

栈

队列

哈希表

基础算法

复杂度分析

二分大法

排序

冒泡排序

搜索

到底是用dfs还是bfs?(3/14)

为什么要写vis数组来标记访问路径?

图论

工具笔记

终端工具

网络连接

ping

curl

curl 常用参数速查表

route

ipconfig

nslookup

ssh

基础操作

进阶操作(待补充)

wget

包管理器

Scoop(推荐)

Winget(不推荐)

–version

构建工具

编程

不支持的

技术文章阅读笔记合集

重构 改善既有代码的设计

ch1: Intro

ch2: 重构的原则

ch3: 代码的坏味道

ch4: 构筑测试体系

ch6: 第一组

提炼函数(Extract Function)

内联函数（Inline Function）

break&总结

程序员自我修养

OUTLINE

编译和链接

程序运行的过程

预处理

编译

汇编

链接

编译的详细原理

词法分析

语法分析

语义分析

中间代码的生成

目标代码的生成与优化

总结

链接概览

补充: 编译全过程;编译器的前端和后端

前端（Frontend）

后端（Backend）

其他项

目标文件: 汇编的产物

目标文件的格式

ELF文件的内容

文件头,段表,重定位表

文件头

魔数详解

段表

重定位表

链接的接口: symbol

符号修饰与函数签名

强弱符号

强弱引用

调试信息

静态链接(4/15)

链接方法

重构改善既有代码的设计