返回专栏
· 17 分钟阅读

栈内存与堆内存(Stack Memory & Heap Memory)


一、什么是栈内存与堆内存?

程序运行时,需要内存保存指令执行过程中的数据,包括局部变量、函数参数、对象、动态数据结构以及临时计算结果等。

按照常见的运行时内存管理模型,可以将内存区域抽象为栈(Stack)和堆(Heap)。

1. 栈内存(Stack Memory)

栈是一种具有后进先出(Last In, First Out,LIFO)特征的数据结构。

在程序运行过程中,函数调用通常会创建新的栈帧(Stack Frame),用于保存当前函数执行所需的上下文信息。

典型内容包括:

  • 函数参数。
  • 局部变量。
  • 返回地址。
  • 保存的寄存器状态。
  • 临时计算数据。
  • 部分调用约定所要求的数据。

当函数调用结束时,对应栈帧通常会被释放。

栈内存的典型特点:

  • 分配和释放通常具有明确的调用边界。
  • 生命周期通常与函数调用过程相关。
  • 管理开销较低。
  • 访问通常具有较好的局部性。
  • 空间容量通常受到线程栈大小限制。

2. 堆内存(Heap Memory)

堆是用于动态内存分配的区域。

程序运行期间,可以根据需要申请内存,并在适当的时候释放。

典型内容包括:

  • 动态创建的对象。
  • 动态数组。
  • 链表、树等动态数据结构。
  • 生命周期跨越多个函数调用的数据。
  • 运行时需要动态管理的复杂数据。

堆内存的典型特点:

  • 分配时间由程序运行过程决定。
  • 生命周期不必与函数调用绑定。
  • 可以支持复杂的数据结构。
  • 需要额外的内存管理机制。
  • 可能出现内存碎片、分配开销和生命周期管理问题。

3. 栈与堆的整体关系

flowchart TD
    A["程序运行"] --> B["内存管理"]
    B --> C["栈内存 Stack"]
    B --> D["堆内存 Heap"]

    C --> E["函数调用栈帧"]
    E --> F["参数、局部变量、返回信息"]

    D --> G["动态分配区域"]
    G --> H["对象、数组、动态数据结构"]

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

需要强调:栈和堆是运行时内存管理模型中的概念。不同语言、操作系统、虚拟机和编译器的实际内存布局可能不同,不能将上述抽象结构理解为所有程序都完全一致的物理内存划分。

二、栈内存的工作机制

1. 函数调用与栈帧

函数调用是理解栈内存最重要的场景。

每次函数调用通常需要记录当前执行状态,以便函数执行完成后能够恢复调用方的执行过程。

这些信息通常组织在栈帧中。

例如:

int add(int a, int b) {
    int result = a + b;
    return result;
}

int main() {
    int x = 10;
    int y = 20;

    int sum = add(x, y);

    return 0;
}

执行过程中,main 和 add 分别对应自己的调用上下文。

概念上可以理解为:

flowchart TD
    A["调用 main()"] --> B["创建 main 栈帧"]
    B --> C["执行 main 中的代码"]
    C --> D["调用 add()"]
    D --> E["创建 add 栈帧"]
    E --> F["执行 add()"]
    F --> G["返回计算结果"]
    G --> H["释放 add 栈帧"]
    H --> I["继续执行 main()"]
    I --> J["main() 返回"]
    J --> K["释放 main 栈帧"]

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

2. 栈帧的结构

一个典型的栈帧可能包含以下内容:

内容 作用
参数 保存函数接收到的参数
局部变量 保存函数内部定义的变量
返回地址 记录函数执行完成后的返回位置
保存寄存器 保存需要跨调用保留的寄存器状态
临时数据 保存部分中间计算结果
调用约定信息 支持参数传递、栈对齐等机制

实际栈帧布局由处理器架构、编译器和调用约定决定。

例如,在 x86-64 平台上,部分参数可能通过寄存器传递,而不是全部放入栈中。

因此,不能认为每个函数的所有参数和局部变量一定都实际存储在栈上。

3. 栈的后进先出机制

假设函数 A 调用函数 B,函数 B 又调用函数 C。

调用关系:

flowchart TD
    A["函数 A"] --> B["函数 B"]
    B --> C["函数 C"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

对应的栈帧关系:

栈顶
┌──────────────────┐
│ 函数 C 的栈帧     │  ← 最后调用
├──────────────────┤
│ 函数 B 的栈帧     │
├──────────────────┤
│ 函数 A 的栈帧     │  ← 最先调用
└──────────────────┘
栈底

函数 C 最先返回,然后是 B,最后是 A。

这正是后进先出的体现。

4. 递归与栈溢出

递归本质上是函数重复调用自身。

每次递归调用通常都会产生新的调用上下文,因此会持续消耗调用栈空间。

int factorial(int n) {
    if (n <= 1) {
        return 1;
    }

    return n * factorial(n - 1);
}

当输入较大或者递归缺少有效终止条件时,可能产生大量栈帧。

最终可能触发栈溢出(Stack Overflow)。

flowchart TD
    A["调用递归函数"] --> B["创建新的栈帧"]
    B --> C{"是否满足终止条件"}
    C -->|"否"| D["继续递归调用"]
    D --> B
    C -->|"是"| E["开始逐层返回"]
    E --> F["释放栈帧"]
    F --> G["递归结束"]

    D --> H["栈空间持续增长"]
    H --> I["超过栈空间限制"]
    I --> J["Stack Overflow"]

    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:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#FFF5DE,stroke:#E8D29A,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

并不是所有递归都必然导致栈溢出,是否溢出取决于递归深度、栈空间大小、编译器优化和运行时实现。

部分语言或运行环境支持尾调用优化,可以减少特定递归调用的栈空间消耗,但不能假设所有语言都会自动进行这种优化。

三、堆内存的工作机制

1. 动态内存分配

堆主要用于支持程序运行期间动态申请和管理内存。

与栈内存通常遵循函数调用生命周期不同,堆对象可以在函数返回之后继续存在。

以 C 语言为例:

#include <stdlib.h>

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

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

    *p = 100;

    free(p);

    return 0;
}

这里:

  • malloc() 申请动态内存。
  • 返回的指针保存所申请内存的地址。
  • *p 访问该内存中的数据。
  • free() 释放动态申请的内存。

堆内存的申请和释放过程可以抽象为:

flowchart TD
    A["程序需要动态内存"] --> B["调用内存分配接口"]
    B --> C{"分配是否成功"}
    C -->|"否"| D["处理分配失败"]
    C -->|"是"| E["获得内存地址"]
    E --> F["使用动态内存"]
    F --> G["不再需要该内存"]
    G --> H["释放内存"]
    H --> I["内存可供后续分配使用"]

    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:#E8EDF2,stroke:#B8C3CE,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#334155
    style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style I fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

2. 堆内存的生命周期

堆对象的生命周期不一定与创建它的函数一致。

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

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

    *p = 100;

    return p;
}

函数返回后,局部指针变量 p 对应的栈帧结束,但动态申请的内存不会因此自动释放。

调用方仍然可以通过返回的指针访问该内存。

int main() {
    int* data = create_data();

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

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

    free(data);

    return 0;
}

这里体现了栈变量和堆对象的生命周期差异:

  • 局部指针变量通常随函数调用结束而失效。
  • 动态申请的内存需要显式释放。
  • 指针变量失效不意味着它指向的内存自动释放。

3. 堆内存管理

堆内存并不是一个简单的连续空间分配器。

运行时内存分配器通常需要维护内存块的状态,处理申请、释放、合并和复用等操作。

常见机制包括:

  • 空闲链表(Free List)。
  • 内存块分割与合并。
  • 内存池(Memory Pool)。
  • 大小分类(Size Classes)。
  • 伙伴系统(Buddy System)。
  • 线程本地缓存。
  • 页级内存管理。

不同语言和运行时使用的具体策略不同。

4. 内存碎片

频繁申请和释放不同大小的内存块,可能造成内存碎片(Memory Fragmentation)。

主要分为两类。

外部碎片(External Fragmentation):

空闲内存分散在多个不连续区域中。

即使空闲内存总量足够,也可能无法找到足够大的连续区域满足一次分配请求。

内部碎片(Internal Fragmentation):

分配器提供的内存块大于实际需要的空间,导致部分已分配空间无法有效利用。

例如,程序需要 30 字节,而分配器按 64 字节大小分配,剩余空间就可能形成内部碎片。

flowchart TD
    A["内存碎片"] --> B["外部碎片"]
    A --> C["内部碎片"]

    B --> D["空闲空间分散"]
    B --> E["缺少足够大的连续区域"]

    C --> F["分配空间大于实际需求"]
    C --> G["已分配区域存在未利用空间"]

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

四、栈与堆的核心区别

对比维度 栈内存 堆内存
英文 Stack Heap
主要用途 函数调用上下文 动态数据分配
管理方式 通常由调用过程自动管理 分配器、垃圾回收器或程序管理
分配方式 通常通过调整栈指针完成 通常通过内存分配器完成
释放方式 通常随栈帧退出而回收 取决于内存管理机制
生命周期 通常与调用上下文相关 可以跨越函数调用
空间特点 通常容量较小且受线程限制 通常容量较大
访问特点 通常具有较好的局部性 访问成本取决于对象布局和访问模式
典型风险 栈溢出、悬空引用 内存泄漏、碎片、悬空指针

需要注意,表格中的“栈更快、堆更慢”只是常见经验总结,并不是所有场景下都成立。

实际性能受到缓存命中率、分配器实现、对象布局、内存访问模式和编译器优化等多种因素影响。

五、栈与堆的内存布局示例

下面以 C 语言程序为例,理解变量、指针和动态内存之间的关系。

#include <stdlib.h>

int main() {
    int a = 10;

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

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

    *p = 20;

    free(p);

    return 0;
}

从概念上看:

  • a 是局部变量。
  • p 是局部指针变量。
  • malloc() 申请的内存用于保存整数 20。
  • p 保存动态内存的地址。

可以抽象为:

flowchart LR
    subgraph S["栈内存 Stack"]
        A["变量 a<br/>10"]
        P["指针变量 p<br/>地址"]
    end

    subgraph H["堆内存 Heap"]
        O["动态分配区域<br/>20"]
    end

    P --> O

    style S fill:#F6FAF7,stroke:#DCE9E0,color:#334155
    style H fill:#F6FAF7,stroke:#DCE9E0,color:#334155
    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style P fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style O fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要注意,这是一种帮助理解的典型模型。C 语言标准并不强制规定局部变量一定在物理栈上,也不保证 malloc() 的实现必须对应某一种固定的物理内存布局。

六、不同编程语言中的栈与堆

栈和堆的概念在不同语言中具有不同的实现方式。

1. C:显式管理动态内存

C 语言提供了直接管理动态内存的接口:

函数 作用
malloc 申请指定大小的内存
calloc 申请内存并清零
realloc 调整已分配内存的大小
free 释放动态内存

示例:

int* numbers = calloc(5, sizeof(int));

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

numbers[0] = 100;

free(numbers);
numbers = NULL;

C 语言不会自动追踪普通动态内存的使用情况。

程序员需要负责管理内存生命周期。

2. C++:手动管理与 RAII

C++ 在继承动态内存管理能力的同时,提供了更高层次的资源管理机制。

传统动态分配:

int* p = new int(100);

delete p;

现代 C++ 更推荐在适当场景使用智能指针:

#include <memory>

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

    return 0;
}

std::unique_ptr 通过 RAII(Resource Acquisition Is Initialization)管理资源生命周期。

当智能指针对象离开作用域时,其管理的动态对象会自动释放。

共享所有权可以使用 std::shared_ptr,但需要注意引用计数和循环引用问题。

3. Java:虚拟机管理堆内存

Java 运行在 JVM 上,具有自动垃圾回收机制。

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

        user.name = "Alice";
    }
}

通常可以这样理解:

  • user 是方法中的局部变量。
  • User 对象由运行时管理。
  • 对象在不再可达且满足回收条件时,可以被垃圾回收器回收。

但不能简单认为 Java 的所有局部变量都在栈上、所有对象都始终在堆上。

JVM 可以进行逃逸分析、标量替换等优化,改变实际的分配和存储方式。

4. Python:对象与自动内存管理

Python 中的数据都是对象。

def create_user():
    user = {
        "name": "Alice",
        "age": 25
    }

    return user

data = create_user()

函数返回后,局部名称 user 不再存在,但返回的字典对象仍然可以通过 data 访问。

在 CPython 中,内存管理主要涉及引用计数和循环垃圾回收。

其他 Python 实现可能采用不同的内存管理策略。

5. Go:逃逸分析与自动内存管理

Go 使用自动内存管理,并通过编译器逃逸分析决定部分变量的分配位置。

func createUser() *User {
    user := User{
        Name: "Alice",
    }

    return &user
}