int* arr = (int*)malloc(100 * sizeof(int));
// 使用 arr...
free(arr);  // 程序员必须记得释放

内存块结构（简化）：
┌─────────────────────────────────────┐
│  Size (4 bytes)  │  Prev Size (4)   │  ← 元数据
├─────────────────────────────────────┤
│                                     │
│         User Data (N bytes)         │  ← 用户实际使用的内存
│                                     │
├─────────────────────────────────────┤
│  Size (4 bytes)  │  FD/BK (8 bytes) │  ← footer + 链表指针（空闲时）
└─────────────────────────────────────┘

// 分配 4 个 100 字节的块
void* a = malloc(100);  // 地址 0x1000
void* b = malloc(100);  // 地址 0x1070
void* c = malloc(100);  // 地址 0x10E0
void* d = malloc(100);  // 地址 0x1150

free(b);  // 释放中间块
free(d);  // 释放另一个中间块

// 现在空闲内存：200 字节，但分散在两个不连续的块中
// 无法分配 150 字节的连续内存 → 外部碎片

void process_data() {
    char* buffer = malloc(1024);
    // 处理数据...
    if (error_occurred) {
        return;  // 忘记 free(buffer)！
    }
    free(buffer);
}

char* get_message() {
    char msg[] = "Hello";  // 栈上分配
    return msg;  // 危险！返回栈地址
}

void use_message() {
    char* p = get_message();
    printf("%s\n", p);  // 未定义行为，可能崩溃或输出乱码
}

void* ptr = malloc(100);
free(ptr);
free(ptr);  // 双重释放！可能导致堆损坏或安全漏洞

std::auto_ptr<int> p(new int(42));
std::auto_ptr<int> q = p;  // p 现在为空！所有权转移
// p 不能再使用，但程序员容易忘记这一点

std::unique_ptr<int> p = std::make_unique<int>(42);
// std::unique_ptr<int> q = p;  // 编译错误！禁止复制
std::unique_ptr<int> q = std::move(p);  // 显式转移所有权
// p 现在为空，q 拥有资源

{
    std::shared_ptr<int> p = std::make_shared<int>(42);
    {
        std::shared_ptr<int> q = p;  // 引用计数 +1
        // 引用计数 = 2
    }  // q 销毁，引用计数 -1 = 1
    // 引用计数 = 1
}  // p 销毁，引用计数 = 0，自动 delete

// shared_ptr 内存布局（简化）
struct ControlBlock {
    int* ptr;           // 指向实际数据
    atomic<int> strong; // 强引用计数
    atomic<int> weak;   // 弱引用计数
    destructor dtor;    // 删除器
};

struct Node {
    std::shared_ptr<Node> next;
};

{
    auto a = std::make_shared<Node>();
    auto b = std::make_shared<Node>();
    a->next = b;
    b->next = a;  // 循环引用！引用计数永不为 0，内存泄漏
}  // a, b 都无法释放

struct Node {
    std::weak_ptr<Node> next;  // 弱引用，不增加引用计数
};

根集合（GC Roots）：
├── 栈上的局部变量
├── 全局变量
├── 寄存器中的引用
└── JNI 引用

可达对象 = 从根集合出发，通过引用链能到达的所有对象
垃圾对象 = 不可达的对象

class MarkSweepGC:
    """
    标记-清除算法演示
    """
    
    def __init__(self, heap_size: int):
        self.heap = [None] * heap_size
        self.allocated = {}  # address -> object
        self.roots = set()   # GC roots
    
    def mark(self) -> set:
        """标记阶段：从根集合出发，标记所有可达对象"""
        marked = set()
        queue = list(self.roots)
        
        while queue:
            obj = queue.pop(0)
            if obj in marked:
                continue
            marked.add(obj)
            
            # 递归标记对象引用的其他对象
            for ref in obj.references:
                if ref not in marked:
                    queue.append(ref)
        
        return marked
    
    def sweep(self, marked: set):
        """清除阶段：回收未标记的对象"""
        to_free = []
        for addr, obj in list(self.allocated.items()):
            if obj not in marked:
                to_free.append(addr)
        
        for addr in to_free:
            del self.allocated[addr]
            self.heap[addr] = None
    
    def gc(self):
        """执行完整 GC"""
        marked = self.mark()
        self.sweep(marked)

初始状态：
┌─────────────────────┬─────────────────────┐
│   From Space (使用)  │    To Space (空闲)   │
│  [A] [B] [C]        │                     │
└─────────────────────┴─────────────────────┘

GC 后：
┌─────────────────────┬─────────────────────┐
│    (现在空闲)        │   To Space (使用)    │
│                     │  [A] [C]            │  ← B 不可达，被丢弃
└─────────────────────┴─────────────────────┘

GC 前（有碎片）：
[A] [B] [空闲] [C] [空闲] [D] [空闲] [空闲]

标记阶段：
[A] [B]        [C]        [D]
 标记 标记      标记       标记

整理阶段（压缩）：
[A] [B] [C] [D] [空闲] [空闲] [空闲] [空闲]

┌─────────────────────────────────────────────────────────┐
│  新生代（Young Generation）                              │
│  ┌─────────────┬─────────────┬─────────────────────┐   │
│  │   Eden      │  Survivor 0 │     Survivor 1      │   │
│  │  (新对象)    │  (存活区)    │      (存活区)        │   │
│  └─────────────┴─────────────┴─────────────────────┘   │
├─────────────────────────────────────────────────────────┤
│  老年代（Old Generation）                                │
│  （长期存活对象）                                         │
├─────────────────────────────────────────────────────────┤
│  永久代/元空间（PermGen/Metaspace）                       │
│  （类元数据）                                             │
└─────────────────────────────────────────────────────────┘

G1 将堆划分为多个 Region（1~32MB）：
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│ Eden│ Eden│Surv │ Old │ Old │ Old │Humong│
│     │     │     │     │     │     │ ous  │
└─────┴─────┴─────┴─────┴─────┴─────┴─────┘

回收策略：
1. 优先回收垃圾最多的 Region（Garbage First）
2. 使用 Remembered Set 避免全堆扫描
3. 可设置目标停顿时间（默认 200ms）

ZGC 核心特性：
├── 并发标记（Concurrent Mark）
├── 并发重定位（Concurrent Relocate）
├── 染色指针（Colored Pointers）
└── 读屏障（Load Barrier）

停顿时间：
- 无论堆大小（100MB ~ 16TB）
- 停顿时间 < 1ms
- 不随堆大小增长而增长

// Go 的内存分配器（简化）
type mspan struct {
    next      *mspan
    prev      *mspan
    startAddr uintptr
    npages    uintptr
    freeindex uintptr
    allocBits *gcBits
    gcmarkBits *gcBits
}

// 内存分配（无锁快速路径）
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    // 1. 小对象（<32KB）：从 P 的 mcache 分配
    // 2. 大对象：直接从 mheap 分配
}

// 设置 GC 目标：当堆增长到上次存活数据的 2 倍时触发 GC
runtime.SetGCPercent(100)  // 默认值

// 强制 GC
runtime.GC()

// 查看 GC 统计
var m runtime.MemStats
runtime.ReadMemStats(&m)
fmt.Printf("GC 次数: %d\n", m.NumGC)
fmt.Printf("GC 停顿: %d ns\n", m.PauseNs[(m.NumGC+255)%256])

金融交易系统要求 P99 延迟 < 1ms
├── GC 停顿 10ms → 违反 SLA
├── GC 停顿 100ms → 交易失败
└── GC 停顿 1s → 系统雪崩

Γ ⊢ e : τ    （在上下文 Γ 中，表达式 e 具有类型 τ）

所有权转移规则：
Γ ⊢ e : T    T 不是 Copy
─────────────────────────
Γ ⊢ move e : T    （e 的所有权转移到新上下文）

借用规则：
Γ ⊢ e : &T     （不可变借用）
Γ ⊢ e : &mut T （可变借用，且 Γ 中没有其他活跃引用）

// 生命周期省略前的显式标注
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

// 编译器推导的约束：
// - x 的生命周期 'a 必须至少与返回值一样长
// - y 的生命周期 'a 必须至少与返回值一样长
// - 返回值的生命周期 'a 不能超过 x 和 y 中较短的那个

1. 为每个引用分配生命周期变量：'a, 'b, 'c...
2. 根据代码结构生成约束：
   - 'a: 'b 表示 'a 至少和 'b 一样长
   - 'b: 'a 表示 'b 至少和 'a 一样长
3. 求解约束系统，检查是否存在解
4. 如果无解，报错："lifetime mismatch"

// 高级抽象写法
let sum: i32 = vec.iter().map(|x| x * 2).sum();

// 编译后等价于：
let mut sum = 0;
for i in 0..vec.len() {
    sum += vec[i] * 2;
}

// 进一步优化后（向量化）：
// SIMD 指令并行处理 4 个元素

// Rust：连续内存，缓存命中率高
let arr: [i32; 1000] = [0; 1000];

// Java：Integer[] 是指针数组，实际数据分散在堆中
Integer[] arr = new Integer[1000];
for (int i = 0; i < 1000; i++) {
    arr[i] = i;  // 每个元素是独立对象
}

let b = Box::new(5);  // 在堆上分配 i32
// 自动实现 Drop，离开作用域时释放

use std::rc::Rc;

let data = Rc::new(vec![1, 2, 3]);
let data2 = Rc::clone(&data);  // 引用计数 +1

println!("引用计数: {}", Rc::strong_count(&data));  // 2

use std::sync::Arc;
use std::thread;

let data = Arc::new(vec![1, 2, 3]);
let data2 = Arc::clone(&data);

thread::spawn(move || {
    println!("子线程: {:?}", data2);
});

use std::cell::RefCell;

let cell = RefCell::new(5);

{
    let mut val = cell.borrow_mut();  // 运行时检查
    *val += 1;
}  // 可变借用结束

let val = cell.borrow();
println!("{}", *val);  // 6

use std::cell::RefCell;
use std::rc::Rc;

// Rc<RefCell<T>> 实现共享可变状态
let shared = Rc::new(RefCell::new(Vec::new()));

let shared2 = Rc::clone(&shared);
shared2.borrow_mut().push(1);

println!("{:?}", shared.borrow());  // [1]

// 编译期计算斐波那契数列
fn fibonacci(comptime n: u32) u32 {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

const result = fibonacci(10);  // 编译期计算，结果为 55

// 编译期类型生成
fn ArrayList(comptime T: type) type {
    return struct {
        items: []T,
        capacity: usize,
        
        pub fn append(self: *@This(), item: T) void {
            // 实现...
        }
    };
}

const IntList = ArrayList(i32);  // 编译期生成类型

const std = @import("std");

// 函数签名明确声明需要分配器
fn parseJson(allocator: std.mem.Allocator, input: []const u8) !Value {
    // 所有内存分配都通过传入的分配器进行
    var parser = std.json.Parser.init(allocator, false);
    defer parser.deinit();
    
    return try parser.parse(input);
}

// 调用方选择分配器
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const allocator = gpa.allocator();

const value = try parseJson(allocator, json_text);
defer value.deinit();

// 1. 通用分配器（类似 malloc）
var gpa = std.heap.GeneralPurposeAllocator(.{}){};

// 2. 固定缓冲区分配器（栈/静态内存）
var buffer: [1024]u8 = undefined;
var fba = std.heap.FixedBufferAllocator.init(&buffer);

// 3.  arena 分配器（一次性释放）
var arena = std.heap.ArenaAllocator.init(allocator);
defer arena.deinit();  // 释放所有分配的内存

// 4. 页面分配器（直接 mmap）
const page_allocator = std.heap.page_allocator;

const File = struct {
    handle: os.fd_t,
    
    pub fn open(path: []const u8) !File {
        const fd = try os.open(path, .{}, 0o666);
        return File{ .handle = fd };
    }
    
    pub fn close(self: File) void {
        os.close(self.handle);
    }
};

// 使用 defer 确保资源释放
fn processFile(path: []const u8) !void {
    const file = try File.open(path);
    defer file.close();  // 无论是否出错，都会执行
    
    var buffer: [1024]u8 = undefined;
    const bytes_read = try file.read(&buffer);
    
    // 处理数据...
}

// !Type 表示可能返回错误联合类型
fn mayFail() !i32 {
    return error.SomeError;
}

// try 关键字：出错时立即返回
fn caller() !i32 {
    const value = try mayFail();  // 如果出错，返回错误
    return value + 1;
}

// catch 关键字：处理错误
fn handleError() i32 {
    const value = mayFail() catch |err| {
        std.log.err("发生错误: {}", .{err});
        return 0;  // 默认值
    };
    return value;
}

// 理论上的区域内存管理（伪代码）
region 'r {
    let a = allocate('r, 100);
    let b = allocate('r, 200);
    // 使用 a, b...
}  // 'r 区域结束，a 和 b 自动释放

对象分类：
├── 栈分配对象：自动释放
├── 小对象池：引用计数
├── 大对象：追踪 GC
└── 循环引用：弱引用 + 周期检测

// 编译期插入 retain/release 调用
// 无运行时 GC，但有引用计数开销
class Person {
    var name: String
    weak var friend: Person?  // 弱引用打破循环
}

(* Coq 证明：链表操作的安全性 *)
Lemma insert_safe: forall (l: list) (x: nat),
  valid_list l -> valid_list (insert l x).
Proof.
  induction l; simpl; auto.
  (* 证明插入操作保持链表有效性 *)
Qed.

项目需求分析：
├── 性能要求极高（游戏引擎、高频交易）
│   └── C++（手动管理）或 Rust（零成本安全）
│
├── 快速开发，延迟不敏感（Web 后端、工具）
│   └── Go（简单 GC）或 Java（成熟生态）
│
├── 嵌入式/系统编程
│   ├── 资源充足 → Rust
│   └── 极度受限 → C
│
├── 需要显式控制（数据库、网络库）
│   └── Zig 或 Rust
│
└── 学术/研究项目
    └── 函数式语言（Haskell/OCaml）或新语言