返回专栏
· 22 分钟阅读

不同语言的内存管理机制


一、什么是内存管理?

内存管理(Memory Management)是指程序在运行过程中,对内存资源进行申请、使用、跟踪、回收和释放的一系列机制。

程序运行时,需要内存保存:

  • 程序指令和代码数据。
  • 局部变量与函数调用信息。
  • 对象、数组和集合。
  • 字符串及其他动态数据。
  • 运行时元数据。
  • 缓存和临时计算结果。

内存管理的核心目标包括:

  1. 正确性:确保程序访问合法的内存区域。
  2. 安全性:避免悬垂指针、重复释放和非法访问。
  3. 效率:降低分配、释放和回收的开销。
  4. 资源控制:避免内存泄漏和不必要的内存占用。
  5. 可预测性:尽量控制内存使用量和释放时机。

1. 内存管理的基本生命周期

一个动态对象通常经历以下阶段:

flowchart TD
    A["程序需要内存"] --> B["申请内存"]
    B --> C["初始化对象"]
    C --> D["读取与修改对象"]
    D --> E{"对象是否继续使用"}
    E -->|是| D
    E -->|否| F["释放或回收内存"]
    F --> G["内存可重新利用"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这里的释放不一定意味着操作系统立即回收对应的物理内存。

很多内存分配器会将已经释放的内存保留在进程内部,以便后续分配复用。

2. 内存管理涉及哪些区域?

以常见的进程内存布局为例,可以抽象为:

内存区域 主要用途 典型内容
代码段 保存程序指令 可执行代码
静态数据区 保存静态存储期数据 全局变量、静态变量
堆 支持动态内存分配 动态对象、容器
栈 支持函数调用 调用帧、局部数据
内存映射区 映射文件及其他资源 共享库、映射文件

需要注意:

  • 不同操作系统和运行时的内存布局并不完全相同。
  • 栈和堆是常见的逻辑内存管理概念,不代表所有对象都必须位于对应区域。
  • 编译器可能进行逃逸分析、寄存器分配和对象消除。
  • 垃圾回收器管理的堆,也不等同于操作系统直接管理的全部进程内存。

二、内存管理的主要模式

不同编程语言采用不同的内存管理策略,但可以归纳为几种主要模式。

1. 手动内存管理

手动内存管理(Manual Memory Management)要求程序员显式控制动态内存的申请与释放。

典型语言:

  • C
  • C++
  • 部分底层系统接口

以 C 语言为例:

#include <stdlib.h>
#include <stdio.h>

int main() {
    int *p = malloc(sizeof(int));

    if (p == NULL) {
        return 1;
    }

    *p = 100;

    printf("%d\n", *p);

    free(p);
    p = NULL;

    return 0;
}

核心操作:

  • malloc():申请指定大小的内存。
  • calloc():申请内存并将其初始化为全零字节。
  • realloc():调整已分配内存块的大小。
  • free():释放动态分配的内存。

手动管理的基本流程:

flowchart TD
    A["确定内存需求"] --> B["调用分配函数"]
    B --> C{"分配成功"}
    C -->|否| D["处理分配失败"]
    C -->|是| E["初始化并使用"]
    E --> F["确保不再使用"]
    F --> G["调用释放函数"]
    G --> H["内存可重新利用"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style D fill:#FBE9E9,stroke:#D9AAAA,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

优点:

  • 内存分配和释放时机可由程序控制。
  • 可以针对具体场景优化内存布局。
  • 运行时管理成本相对可控。
  • 适合操作系统、嵌入式和底层基础设施。

缺点:

  • 容易出现内存泄漏。
  • 容易发生重复释放。
  • 容易出现悬垂指针。
  • 复杂对象关系难以维护。
  • 多线程环境下需要额外处理并发访问与释放问题。

需要特别注意:free() 只负责释放内存,并不会自动将其他指向该内存的指针全部清空。

例如:

int *p = malloc(sizeof(int));
int *q = p;

free(p);

// q 仍然保存原地址,但该地址已经不能再通过 q 访问

此时 q 就成为悬垂指针。

2. 垃圾回收机制

垃圾回收(Garbage Collection,GC)通过运行时自动识别不再需要的对象,并回收其占用的内存。

典型语言:

  • Java
  • C#
  • Go
  • JavaScript
  • Python(CPython 主要通过引用计数和循环垃圾回收)

程序通常不需要显式释放普通托管对象。

例如 Java:

public class Main {
    public static void main(String[] args) {
        User user = new User();

        user.name = "Alice";

        user = null;
    }
}

当对象不再被程序引用时,它可能成为垃圾回收候选对象。

但这并不意味着对象在执行 user = null 后立即释放。

垃圾回收器会根据自身策略决定何时回收。

基本过程:

flowchart TD
    A["创建对象"] --> B["对象进入托管堆"]
    B --> C["程序持有对象引用"]
    C --> D["引用关系发生变化"]
    D --> E["GC 判断对象可达性"]
    E --> F{"对象是否可达"}
    F -->|是| G["保留对象"]
    F -->|否| H["标记为可回收"]
    H --> I["执行垃圾回收"]
    I --> J["回收或整理内存"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#FBE9E9,stroke:#D9AAAA,color:#334155
    style I fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style J fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

优点:

  • 减少手动释放内存的工作。
  • 降低部分内存安全错误的发生概率。
  • 简化对象之间的引用管理。
  • 适合复杂对象关系和大型应用开发。

缺点:

  • 垃圾回收会消耗 CPU 和内存资源。
  • 回收时机通常不可由业务代码精确控制。
  • 可能产生暂停或尾延迟波动。
  • 仍可能出现逻辑意义上的内存泄漏。

尤其需要注意:

使用 GC 不等于不会发生内存泄漏。

只要对象仍然可以从 GC 根对象访问,即使业务已经不再需要它,垃圾回收器也可能继续保留它。

例如:

import java.util.ArrayList;
import java.util.List;

public class Cache {
    private static final List<byte[]> DATA = new ArrayList<>();

    public static void add() {
        DATA.add(new byte[1024 * 1024]);
    }
}

如果 DATA 持续增长且没有清理策略,集合中的对象就会一直保持可达,最终可能导致内存耗尽。

3. 自动引用计数

引用计数(Reference Counting)通过记录对象当前被多少个引用持有,判断对象是否可以释放。

当引用计数增加时,说明新增了一个所有者或引用关系;当引用计数减少时,说明某个引用关系被移除。

当引用计数归零时,对象通常可以立即释放。

Python 的 CPython 实现就使用引用计数作为主要内存管理机制,并结合循环垃圾回收处理引用环。

例如:

class User:
    def __init__(self, name):
        self.name = name

user = User("Alice")
another = user

del user
del another

当两个变量都不再引用对象时,该对象的引用计数可能归零。

引用计数的简化过程:

flowchart TD
    A["创建对象"] --> B["引用计数初始化"]
    B --> C["新增引用"]
    C --> D["引用计数增加"]
    D --> E["移除引用"]
    E --> F["引用计数减少"]
    F --> G{"引用计数是否为零"}
    G -->|否| C
    G -->|是| H["释放对象"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

优点:

  • 对象引用计数归零时通常可以立即释放。
  • 不需要等待完整的堆扫描周期。
  • 对部分资源释放场景具有较好的及时性。
  • 实现思路相对直观。

缺点:

  • 引用计数更新需要额外开销。
  • 引用关系复杂时管理成本较高。
  • 循环引用可能导致对象无法释放。
  • 多线程环境下需要正确处理计数更新的并发安全。

循环引用问题

例如:

class Node:
    pass

a = Node()
b = Node()

a.other = b
b.other = a

del a
del b

两个对象互相引用,即使外部变量已经删除,它们之间仍然存在引用关系。

因此,引用计数不一定能够将它们释放。

CPython 使用循环垃圾回收机制补充处理这类问题。

4. 所有权与借用机制

所有权(Ownership)是 Rust 的核心内存管理机制。

它不依赖传统的运行时垃圾回收器,而是在编译阶段通过所有权规则、借用检查和生命周期约束,确保引用使用符合内存安全要求。

核心规则:

  1. 每个值都有一个所有者。
  2. 同一时间,一个值只有一个主要所有者。
  3. 所有者离开作用域时,其拥有的值会被销毁。
  4. 值可以通过移动转移所有权。
  5. 借用引用受到规则约束。

例如:

fn main() {
    let user = String::from("Alice");

    let another = user;

    println!("{}", another);
}

这里 user 的所有权被移动给 another。

移动完成后,不能再通过 user 使用原来的字符串。

fn main() {
    let user = String::from("Alice");

    let name = &user;

    println!("{}", name);
    println!("{}", user);
}

这里使用不可变借用,name 只是引用,不会获得字符串的所有权。

Rust 借用检查器会在编译阶段检查引用是否满足规则,避免大量悬垂引用和数据竞争问题。

基本过程:

flowchart TD
    A["创建值"] --> B["建立所有权"]
    B --> C{"如何使用值"}
    C -->|移动| D["转移所有权"]
    C -->|借用| E["创建引用"]
    D --> F["新所有者管理值"]
    E --> G["借用检查"]
    G --> H{"借用是否合法"}
    H -->|否| I["编译错误"]
    H -->|是| J["通过引用访问"]
    F --> K["所有者离开作用域"]
    J --> K
    K --> L["自动销毁值"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style I fill:#FBE9E9,stroke:#D9AAAA,color:#334155
    style J fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style K fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style L fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

优点:

  • 大量内存安全问题可以在编译期发现。
  • 通常不需要传统 GC。
  • 对象销毁时机具有较强的可预测性。
  • 可以在不依赖全局垃圾回收器的情况下管理复杂资源。

缺点:

  • 所有权和借用规则需要学习成本。
  • 复杂引用关系可能需要调整数据结构。
  • 某些场景需要使用 Rc、Arc 和内部可变性机制。
  • 编译器无法静态表达所有运行时业务约束,unsafe 代码仍需要开发者保证安全性。

需要强调:Rust 生命周期注解约束引用的有效范围,不会延长被引用对象本身的生命周期。

5. RAII 与资源自动管理

RAII(Resource Acquisition Is Initialization)是 C++ 中重要的资源管理思想。

它将资源的获取与对象生命周期绑定:

  • 对象构造时获取资源。
  • 对象销毁时释放资源。
  • 通过作用域和对象生命周期管理资源。

例如:

#include <iostream>
#include <memory>

class User {
public:
    User() {
        std::cout << "Created\n";
    }

    ~User() {
        std::cout << "Destroyed\n";
    }
};

int main() {
    {
        auto user = std::make_unique<User>();
    }

    return 0;
}

当 user 离开作用域时,unique_ptr 自动销毁所管理的对象。

RAII 不等于垃圾回收。

它仍然依赖确定的对象生命周期和析构规则,只是通过语言机制自动执行资源释放逻辑。

RAII 不仅适用于内存,还适用于:

  • 文件句柄。
  • 互斥锁。
  • 网络连接。
  • 数据库连接。
  • 操作系统资源。

三、主流语言的内存管理机制

不同语言的内存管理策略有明显区别,实际理解时需要结合语言规范与具体实现。

1. C:手动内存管理

C 语言通常通过 malloc()、calloc()、realloc() 和 free() 管理动态内存。

示例:

#include <stdlib.h>

int main() {
    int *data = malloc(10 * sizeof(int));

    if (data == NULL) {
        return 1;
    }

    data[0] = 100;

    free(data);

    return 0;
}

特点:

  • 动态内存由程序员显式申请和释放。
  • 指针允许直接操作内存地址。
  • 不提供语言级自动垃圾回收。
  • 需要开发者自行维护资源生命周期。

常见问题:

  • 内存泄漏。
  • 缓冲区溢出。
  • 越界访问。
  • 重复释放。
  • 悬垂指针。
  • 未初始化内存访问。

2. C++:RAII 与智能指针

C++ 支持手动内存管理,也提供 RAII、智能指针和容器等机制。

常见智能指针:

智能指针 管理方式 适用场景
std::unique_ptr 独占所有权 单一对象所有者
std::shared_ptr 共享引用计数 多处共享对象
std::weak_ptr 弱引用,不增加强引用计数 观察共享对象、打破循环引用

示例:

#include <memory>
#include <iostream>

int main() {
    auto user = std::make_unique<int>(100);

    std::cout << *user << std::endl;

    return 0;
}

unique_ptr 离开作用域时会自动释放对象。

使用 shared_ptr 时,通常通过引用计数管理对象生命周期:

#include <memory>

int main() {
    auto a = std::make_shared<int>(100);

    {
        auto b = a;
    }

    return 0;
}

当最后一个强引用被销毁时,托管对象才会被释放。

需要注意:shared_ptr 的引用计数无法自动解决强引用循环,通常需要合理使用 weak_ptr。

3. Rust:所有权与借用检查

Rust 使用所有权系统管理内存。

示例:

fn main() {
    let value = String::from("Hello");

    let borrowed = &value;

    println!("{}", borrowed);
    println!("{}", value);
}

对于共享所有权,Rust 提供:

  • Rc<T>:单线程环境下的引用计数。
  • Arc<T>:支持线程间共享的原子引用计数。
  • Box<T>:在堆上分配并独占管理对象。
  • RefCell<T>:运行时检查借用规则。
  • Mutex<T>:通过互斥锁控制并发访问。

这些机制并不意味着 Rust 有传统的自动追踪式 GC。

4. Java:JVM 垃圾回收

Java 对象通常由 JVM 的托管堆管理。

示例:

public class Main {
    public static void main(String[] args) {
        User user = new User();

        user.name = "Alice";

        user = null;
    }
}

Java 垃圾回收器负责判断对象是否仍然可达。

常见 GC 实现包括:

  • Serial GC
  • Parallel GC
  • G1 GC
  • ZGC
  • Shenandoah GC

不同收集器在吞吐量、暂停时间和内存开销方面有不同取舍。

Java 也提供 try-with-resources 管理文件、连接等非内存资源:

try (var input = new java.io.FileInputStream("data.txt")) {
    System.out.println(input.read());
}

普通 Java 对象的内存回收由 GC 管理,但文件句柄等外部资源仍然应该显式关闭或使用资源管理结构。

5. C#:CLR 垃圾回收

C# 运行在 .NET CLR 运行时环境中,普通托管对象主要由 GC 管理。

例如:

public class User
{
    public string Name { get; set; }
}

class Program
{
    static void Main()
    {
        var user = new User();

        user.Name = "Alice";

        user = null;
    }
}

.NET GC 通常采用分代回收思想。

常见代际:

  • Gen 0:通常存放较年轻的对象。
  • Gen 1:作为中间代。
  • Gen 2:通常存放存活时间较长的对象。

此外,C# 通过 IDisposable、using 和 SafeHandle 等机制管理非托管资源。

Dispose() 负责确定性释放资源,而不是要求 GC 立即回收托管对象。

6. Go:并发垃圾回收

Go 采用自动垃圾回收机制,常见实现使用并发标记清扫策略。

例如:

package main

type User struct {
    Name string
}

func main() {
    user := &User{
        Name: "Alice",
    }

    _ = user
}

Go 编译器会进行逃逸分析,判断变量是否可以安全地放在栈上,或者是否需要在堆上分配。

Go 的内存管理涉及:

  • 垃圾回收器。
  • 内存分配器。
  • 逃逸分析。
  • 栈增长机制。
  • 并发标记与清扫。

Go 并不是所有对象都分配在堆上,也不是所有对象都由 GC 回收。

7. Python:引用计数与循环 GC

以 CPython 为例,Python 主要采用引用计数管理对象,并通过循环垃圾回收处理特定引用环。

示例:

class User:
    def __init__(self, name):
        self.name = name

user = User("Alice")

another = user

del user
del another

特点:

  • 对象通常由 Python 运行时管理。
  • 引用计数用于追踪对象引用数量。
  • 循环 GC 处理部分不可达引用环。
  • 对象内存释放后,分配器不一定立即将内存归还操作系统。

不同 Python 实现的内存管理方式可能不同,不能把 CPython 的机制直接视为 Python 语言规范。

8. JavaScript:自动内存管理

现代 JavaScript 引擎通常采用可达性分析与垃圾回收管理对象内存。

例如:

function createUser() {
    const user = {
        name: "Alice"
    };

    return user;
}

let currentUser = createUser();

currentUser = null;

当对象不再从 GC 根对象可达时,就可能成为垃圾回收候选对象。

JavaScript 引擎通常还会采用:

  • 分代回收。
  • 增量标记。
  • 并发标记。
  • 对象整理。
  • 内存分配优化。

具体策略由引擎实现决定。

9. 不同语言内存管理汇总

语言 主要机制 释放方式 主要特点
C 手动管理 显式释放 控制能力强
C++ RAII、智能指针 作用域与所有权管理 资源释放确定性较强
Rust 所有权与借用 所有者离开作用域 编译期安全检查
Java GC 垃圾回收器 托管堆管理
C# GC 垃圾回收器 托管与非托管资源分离管理
Go GC 垃圾回收器 并发垃圾回收
Python 引用计数与循环 GC 运行时管理 动态对象管理
JavaScript 可达性分析与 GC 引擎自动回收 动态运行时管理

四、垃圾回收的核心算法

理解 GC,需要进一步了解垃圾回收器如何判断对象是否可以释放。

1. 引用计数

引用计数通过记录对象被引用的数量判断对象是否可以释放。

核心规则:

  • 新增强引用时,计数增加。
  • 删除强引用时,计数减少。
  • 计数为零时,可以释放对象。

优点:

  • 对象释放通常较及时。
  • 不需要每次都遍历整个对象图。
  • 实现概念直观。

缺点:

  • 引用更新存在额外开销。
  • 循环引用难以处理。
  • 多线程环境下需要正确同步。

2. 标记清除(Mark-Sweep)

标记清除是经典的追踪式垃圾回收算法。

主要分为两个阶段:

标记阶段

从 GC Roots 出发,遍历所有可达对象,并标记它们。

清除阶段

遍历堆中的对象,将未被标记的对象回收。

flowchart TD
    A["开始垃圾回收"] --> B["确定 GC Roots"]
    B --> C["遍历对象引用关系"]
    C --> D["标记可达对象"]
    D --> E["扫描堆内存"]
    E --> F{"对象是否被标记"}
    F -->|是| G["保留对象"]
    F -->|否| H["回收对象"]
    G --> I["结束本轮回收"]
    H --> I

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#FBE9E9,stroke:#D9AAAA,color:#334155
    style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

优点:

  • 能够处理循环引用。
  • 不需要为每个对象维护精确引用计数。
  • 可以管理复杂对象图。

缺点:

  • 需要遍历对象引用关系。
  • 可能产生较大的回收开销。
  • 单纯清除可能导致内存碎片。