1
虚拟地址 ---[MMU(内存管理单元)]---> 物理地址
2
                |
3
                v
4
          页表(Page Table)

1
虚拟地址 = [页号 | 页内偏移]
2
         ↓
3
   查询页表
4
         ↓
5
物理地址 = [页框号 | 页内偏移]

1
64位系统典型结构:
2
虚拟地址 = [L4索引 | L3索引 | L2索引 | L1索引 | 偏移]
3
           9位     9位     9位     9位    12位

1
struct page_table_entry {
2
    unsigned long pfn : 40;      // 页框号(Physical Frame Number)
3
    unsigned int present : 1;     // 存在位
4
    unsigned int writable : 1;    // 可写位
5
    unsigned int user : 1;        // 用户态可访问
6
    unsigned int accessed : 1;    // 访问位(用于LRU)
7
    unsigned int dirty : 1;       // 修改位(写回磁盘时检查)
8
    unsigned int reserved : 19;   // 其他标志位
9
};

1
struct reverse_mapping {
2
    struct process *owner;   // 哪个进程拥有此页框
3
    unsigned long vaddr;     // 对应的虚拟地址
4
    struct list_head list;   // 多个进程可能共享(COW)
5
};

1
struct vm_area_struct {
2
    unsigned long vm_start;   // 起始虚拟地址
3
    unsigned long vm_end;     // 结束虚拟地址
4
    struct mm_struct *vm_mm;  // 所属进程
5
    pgprot_t vm_page_prot;    // 访问权限
6
    unsigned long vm_flags;   // 标志(共享/私有/可执行等)
7
    struct file *vm_file;     // 映射的文件(内存映射文件)
8
};

1
fork()创建子进程时:
2
父子进程共享相同物理页 → 页表项标记为只读
3
任一方尝试写入 → 触发异常 → 复制页面 → 各自修改副本

1
1. 保存当前进程上下文（寄存器、PC、页表等）
2
2. 切换到内核态
3
3. 调度器选择下一个进程
4
4. 切换页表和地址空间（TLB失效）
5
5. 恢复新进程上下文
6
6. 切换回用户态
7
时间开销：微秒级（1-10μs）

1
1. 保存当前线程上下文（寄存器、PC、栈指针）
2
2. 切换到内核态
3
3. 调度器选择下一个线程
4
4. 如果是同进程线程，无需切换页表
5
5. 恢复新线程上下文
6
6. 切换回用户态
7
时间开销：亚微秒级（0.1-1μs）

1
1. 保存当前协程上下文（用户态寄存器、栈指针）
2
2. 用户态调度器选择下一个协程
3
3. 恢复新协程上下文
4
4. 继续执行
5
时间开销：纳秒级（几十到几百ns）
6
无内核介入，无系统调用

1
进程地址空间（Linux为例）：
2
0xFFFFFFFF  ┌─────────────┐
3
            │   内核空间   │ （1GB）
4
0xC0000000  ├─────────────┤
5
            │     栈       │ ↓ 向下增长
6
            ├─────────────┤
7
            │     堆       │ ↑ 向上增长
8
            ├─────────────┤
9
            │   BSS段      │
10
            ├─────────────┤
11
            │   数据段     │
12
            ├─────────────┤
13
            │   代码段     │
14
0x00000000  └─────────────┘

1
struct task_struct {
2
    pid_t pid;                    // 进程ID
3
    struct mm_struct *mm;         // 内存描述符
4
    struct files_struct *files;   // 打开文件表
5
    struct signal_struct *signal; // 信号处理
6
    // ... 数百个字段
7
};

1
同一进程的线程共享：
2
✓ 代码段、数据段
3
✓ 堆内存
4
✓ 文件描述符
5
✓ 信号处理器
6
✓ 进程ID
7

8
线程独享：
9
✓ 线程ID（TID）
10
✓ 栈空间
11
✓ 寄存器状态
12
✓ 错误码（errno）

1
# 协程本质：可中断可恢复的函数
2
def coroutine_example():
3
    print("开始执行")
4
    yield  # 中断点，保存上下文
5
    print("恢复执行")

1
; x86-64 上下文切换简化版
2
context_switch:
3
    ; 保存旧上下文
4
    push rbx
5
    push rbp
6
    push r12-r15
7
    mov [old_rsp], rsp
8

9
    ; 加载新上下文
10
    mov rsp, [new_rsp]
11
    pop r15-r12
12
    pop rbp
13
    pop rbx
14
    ret

1
虚拟运行时间 = 实际运行时间 × (NICE_0_LOAD / 权重)
2
选择vruntime最小的任务运行

1
# 场景：CPU密集型任务并行 + 需要强隔离
2
from multiprocessing import Process
3

4
def cpu_intensive_task(data):
5
    # 复杂计算
6
    result = heavy_computation(data)
7
    return result
8

9
if __name__ == '__main__':
10
    processes = []
11
    for i in range(4):  # 利用多核
12
        p = Process(target=cpu_intensive_task, args=(data[i],))
13
        processes.append(p)
14
        p.start()

1
// 场景：需要共享内存的并发任务
2
public class WebServer {
3
    private ExecutorService threadPool =
4
        Executors.newFixedThreadPool(200);
5

6
    public void handleRequest(Request req) {
7
        threadPool.submit(() -> {
8
            // 共享缓存、配置等
9
            processRequest(req);
10
        });
11
    }
12
}

1
# 场景：高并发IO密集型任务
2
import asyncio
3

4
async def handle_client(reader, writer):
5
    data = await reader.read(1024)  # 非阻塞
6
    response = await process_data(data)  # 异步处理
7
    writer.write(response)
8
    await writer.drain()
9

10
async def main():
11
    server = await asyncio.start_server(
12
        handle_client, '0.0.0.0', 8888)
13
    async with server:
14
        await server.serve_forever()
15

16
# 可以轻松支持10万+并发连接

1
是否需要强隔离？
2
├─ 是 → 进程
3
└─ 否 → 是否需要利用多核？
4
    ├─ 是（CPU密集）→ 线程/进程池
5
    └─ 否（IO密集）→ 协程

1
Bootstrap ClassLoader (启动类加载器)
2
    ↑
3
Extension ClassLoader (扩展类加载器)
4
    ↑
5
Application ClassLoader (应用类加载器)
6
    ↑
7
Custom ClassLoader (自定义类加载器)

1
public class CustomClassLoader extends ClassLoader {
2

3
    @Override
4
    public Class<?> loadClass(String name) throws ClassNotFoundException {
5
        // 不委派给父加载器，直接自己加载
6
        if (name.startsWith("com.myapp")) {
7
            return findClass(name);
8
        }
9
        // 其他类仍然使用双亲委派
10
        return super.loadClass(name);
11
    }
12

13
    @Override
14
    protected Class<?> findClass(String name) throws ClassNotFoundException {
15
        // 从自定义路径加载类的字节码
16
        byte[] classData = loadClassData(name);
17
        if (classData == null) {
18
            throw new ClassNotFoundException();
19
        }
20
        return defineClass(name, classData, 0, classData.length);
21
    }
22

23
    private byte[] loadClassData(String className) {
24
        // 实现从文件系统或网络加载字节码
25
        // ...
26
        return null;
27
    }
28
}

1
// JDBC驱动加载示例
2
Thread.currentThread().setContextClassLoader(customClassLoader);
3
// DriverManager会使用线程上下文类加载器加载驱动
4
Class.forName("com.mysql.jdbc.Driver");

1
protected Class<?> loadClass(String name, boolean resolve)
2
    throws ClassNotFoundException {
3
    synchronized (getClassLoadingLock(name)) {
4
        // 1. 检查类是否已经被加载
5
        Class<?> c = findLoadedClass(name);
6
        if (c == null) {
7
            try {
8
                if (parent != null) {
9
                    // 2. 委派给父加载器
10
                    c = parent.loadClass(name, false);
11
                } else {
12
                    // 父加载器为null，使用启动类加载器
13
                    c = findBootstrapClassOrNull(name);
14
                }
15
            } catch (ClassNotFoundException e) {
16
                // 父加载器无法加载
17
            }
18

19
            if (c == null) {
20
                // 3. 父加载器无法加载，自己加载
21
                c = findClass(name);
22
            }
23
        }
24
        if (resolve) {
25
            resolveClass(c);
26
        }
27
        return c;
28
    }
29
}

1
@Override
2
protected Class<?> findClass(String name) throws ClassNotFoundException {
3
    // 1. 根据类名获取字节码
4
    byte[] classData = getClassData(name);
5

6
    if (classData == null) {
7
        throw new ClassNotFoundException(name);
8
    }
9

10
    // 2. 将字节码转换为Class对象
11
    return defineClass(name, classData, 0, classData.length);
12
}

1
// 悲观锁示例
2
synchronized(obj) {
3
    // 独占访问
4
    data++;
5
}

1
// CAS乐观锁示例
2
AtomicInteger count = new AtomicInteger(0);
3
count.compareAndSet(0, 1); // 期望值为0时更新为1

1
// 修饰方法
2
public synchronized void method() {}
3

4
// 修饰代码块
5
synchronized(this) {
6
    // 临界区代码
7
}

1
ReentrantLock lock = new ReentrantLock(true); // 公平锁
2
lock.lock();
3
try {
4
    // 临界区
5
} finally {
6
    lock.unlock();
7
}

1
Semaphore semaphore = new Semaphore(3); // 允许3个线程同时访问
2
semaphore.acquire(); // 获取许可
3
try {
4
    // 访问资源
5
} finally {
6
    semaphore.release(); // 释放许可
7
}

1
CountDownLatch latch = new CountDownLatch(3); // 计数器=3
2

3
// 工作线程
4
new Thread(() -> {
5
    // 执行任务
6
    latch.countDown(); // 计数-1
7
}).start();
8

9
// 主线程等待
10
latch.await(); // 阻塞直到计数=0

1
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
2
    System.out.println("所有线程已到达");
3
});
4

5
// 每个线程
6
barrier.await(); // 等待其他线程

1
Phaser phaser = new Phaser(3); // 3个参与者
2

3
// 线程执行
4
phaser.arriveAndAwaitAdvance(); // 到达第一阶段并等待
5
// 继续执行
6
phaser.arriveAndAwaitAdvance(); // 到达第二阶段并等待
7

8
phaser.arriveAndDeregister(); // 完成并注销

1
// 跳表节点
2
typedef struct zskiplistNode {
3
    sds ele;                    // 成员对象
4
    double score;               // 分值
5
    struct zskiplistNode *backward;  // 后退指针
6
    struct zskiplistLevel {
7
        struct zskiplistNode *forward;  // 前进指针
8
        unsigned long span;             // 跨度（到下个节点的距离）
9
    } level[];                  // 层级数组
10
} zskiplistNode;
11

12
// 跳表结构
13
typedef struct zskiplist {
14
    struct zskiplistNode *header, *tail;  // 头尾指针
15
    unsigned long length;                  // 节点数量
16
    int level;                             // 最大层数
17
} zskiplist;

1
Level 3:  head ---------------------------------> node4 ----> NULL
2
Level 2:  head ----------> node2 -------------> node4 ----> NULL
3
Level 1:  head --> node1 -> node2 -> node3 --> node4 ----> NULL
4
Level 0:  head -> node1 -> node2 -> node3 -> node4 -> tail
5
         (score: 1)  (score: 5) (score: 10) (score: 15)

1
def insert(skiplist, score, member):
2
    # 1. 随机生成层数（1-32层）
3
    level = random_level()  # 概率 P=0.25
4

5
    # 2. 从最高层开始查找插入位置
6
    update = [None] * MAX_LEVEL  # 记录每层的前驱节点
7
    current = skiplist.header
8

9
    for i in range(skiplist.level - 1, -1, -1):
10
        while current.level[i].forward and \
11
              current.level[i].forward.score < score:
12
            current = current.level[i].forward
13
        update[i] = current  # 记录该层的插入位置
14

15
    # 3. 创建新节点
16
    new_node = create_node(level, score, member)
17

18
    # 4. 更新各层指针
19
    for i in range(level):
20
        new_node.level[i].forward = update[i].level[i].forward
21
        update[i].level[i].forward = new_node
22

23
        # 更新跨度
24
        new_node.level[i].span = update[i].level[i].span - rank[0] + rank[i]
25
        update[i].level[i].span = rank[0] - rank[i] + 1

1
def delete(skiplist, score, member):
2
    # 1. 查找目标节点
3
    update = [None] * MAX_LEVEL
4
    current = skiplist.header
5

6
    for i in range(skiplist.level - 1, -1, -1):
7
        while current.level[i].forward and \
8
              (current.level[i].forward.score < score or \
9
               (current.level[i].forward.score == score and \
10
                current.level[i].forward.member < member)):
11
            current = current.level[i].forward
12
        update[i] = current
13

14
    # 2. 删除节点（更新各层指针）
15
    target = current.level[0].forward
16
    if target and target.score == score and target.member == member:
17
        for i in range(skiplist.level):
18
            if update[i].level[i].forward == target:
19
                update[i].level[i].forward = target.level[i].forward
20
                update[i].level[i].span += target.level[i].span - 1
21
            else:
22
                update[i].level[i].span -= 1
23

24
        free(target)

1
HASH_SLOT = CRC16(key) & 16383  // 等价于 CRC16(key) % 16384

1
*3\r\n
2
$3\r\nSET\r\n
3
$4\r\nname\r\n
4
$5\r\nredis\r\n

1
+OK\r\n

1
*2\r\n
2
$3\r\nGET\r\n
3
$4\r\nname\r\n

1
$5\r\nredis\r\n

1
-- 使用LIMIT直接获取前100名
2
SELECT student_id, student_name, score
3
FROM student_scores
4
ORDER BY score DESC
5
LIMIT 100;

1
-- 如果需要分页展示
2
SELECT student_id, student_name, score
3
FROM student_scores
4
ORDER BY score DESC
5
LIMIT 100 OFFSET 0;

1
public List<Student> getTop100(List<Student> students) {
2
    // 使用小顶堆，保持堆大小为100
3
    PriorityQueue<Student> minHeap = new PriorityQueue<>(
4
        100,
5
        Comparator.comparingInt(Student::getScore)
6
    );
7

8
    for (Student student : students) {
9
        if (minHeap.size() < 100) {
10
            minHeap.offer(student);
11
        } else if (student.getScore() > minHeap.peek().getScore()) {
12
            minHeap.poll();
13
            minHeap.offer(student);
14
        }
15
    }
16

17
    // 转换为降序列表
18
    List<Student> result = new ArrayList<>(minHeap);
19
    result.sort(Comparator.comparingInt(Student::getScore).reversed());
20
    return result;
21
}

1
-- 各节点执行
2
SELECT * FROM student_scores ORDER BY score DESC LIMIT 100;
3

4
-- 汇总后再排序
5
SELECT * FROM (
6
    SELECT * FROM node1_top100
7
    UNION ALL
8
    SELECT * FROM node2_top100
9
    UNION ALL
10
    SELECT * FROM node3_top100
11
) AS combined
12
ORDER BY score DESC
13
LIMIT 100;

1
mysql -h host -P port -u user -p password

1
SELECT * FROM users WHERE id = 1;

1
SELECT student_name FROM students WHERE score > 90;

1
SELECT * FROM t1
2
JOIN t2 ON t1.id = t2.t1_id
3
WHERE t1.status = 1 AND t2.type = 'A';

1
方案1: 全表扫描 t1 → 成本: 10000
2
方案2: 使用 idx_status → 成本: 500  ✓ 选择此方案

1
-- 再次验证权限
2
SELECT privilege FROM mysql.user WHERE user = 'current_user';

1
1. 调用存储引擎接口打开表
2
   ↓
3
2. 根据索引取第一行，判断条件
4
   ↓
5
3. 满足条件 → 加入结果集
6
   ↓
7
4. 取下一行，重复步骤2-3
8
   ↓
9
5. 返回结果集给客户端

1
InnoDB handler APIs:
2
- ha_index_init()    // 初始化索引
3
- ha_index_next()    // 获取下一行
4
- ha_index_end()     // 结束索引扫描