嵌入式之 LVGL 的切换页面研究：杜绝内存泄漏（单片机与 Linux 平台）（链表与多进程方式）

一、前言

LVGL（Light and Versatile Graphics Library）作为嵌入式领域主流的开源 GUI 库，凭借轻量化、跨平台、易扩展的特性，广泛应用于单片机（STM32/ESP32 等）和 Linux（ARM/x86）平台。页面切换是 LVGL 开发中的高频操作，但如果管理不当，极易引发内存泄漏------ 单片机资源有限（KB 级 RAM），泄漏会直接导致系统死机；Linux 平台虽内存充裕，但长期运行的进程内存泄漏会导致系统资源耗尽。

本文针对单片机（无进程 / RTOS）和 Linux（多进程）两大场景，分别提出链表式页面管理 （单片机）和多进程页面隔离（Linux）方案，从设计层面杜绝 LVGL 页面切换的内存泄漏问题。

二、LVGL 页面切换内存泄漏的核心痛点

内存泄漏的本质是 "申请的内存未被释放，且无法被再次访问"，LVGL 页面切换中常见泄漏场景：

切换页面时仅隐藏旧页面，未销毁 LVGL 对象（lv_obj），导致对象占用的内存永久无法回收；
页面内的动态资源（图片、字体、缓存）未显式释放，LVGL 内置的内存管理无法自动回收；
重复创建页面对象（如多次调用页面初始化函数），旧对象指针丢失，形成野指针 + 内存泄漏；
Linux 平台下多页面共享进程空间，资源释放不彻底导致跨页面内存污染。

三、通用设计原则：页面生命周期管理

无论单片机还是 Linux 平台，杜绝内存泄漏的核心是标准化页面生命周期，确保 "申请 - 使用 - 释放" 闭环：

plaintext

复制代码

页面生命周期 = 注册 → 创建 → 显示 → 隐藏 → 销毁 → 注销

所有页面必须实现统一的生命周期接口，切换时严格执行 "销毁旧页面→释放资源→创建新页面" 流程。

四、单片机平台：基于链表的 LVGL 页面管理

4.1 单片机平台特性

单片机（如 STM32F4/ESP32）资源受限：RAM 通常几十 KB~ 几 MB，无进程概念（裸机 / RTOS 线程），所有页面共享同一内存空间。因此需通过链表统一管理所有页面的元信息（句柄、状态、生命周期函数），确保切换时精准释放资源。

4.2 核心设计：链表结构定义

链表节点存储单个页面的核心信息，包括页面句柄、状态（创建 / 显示 / 隐藏）、生命周期函数（创建 / 销毁）：

运行

复制代码

#include "lvgl/lvgl.h"
#include <stdint.h>

// 页面状态枚举
typedef enum {
    PAGE_STATE_UNUSED = 0,  // 未使用
    PAGE_STATE_CREATED,     // 已创建
    PAGE_STATE_SHOWING      // 正在显示
} page_state_t;

// 页面操作函数指针（统一生命周期接口）
typedef void (*page_create_cb)(lv_obj_t **page);  // 创建页面
typedef void (*page_destroy_cb)(lv_obj_t *page);  // 销毁页面

// 链表节点：单个页面的元信息
typedef struct page_node {
    uint8_t page_id;                // 页面唯一ID
    page_state_t state;             // 页面状态
    lv_obj_t *page_obj;             // 页面根对象句柄
    page_create_cb create_func;     // 创建函数
    page_destroy_cb destroy_func;   // 销毁函数
    struct page_node *next;         // 下一个节点
} page_node_t;

// 页面管理链表（头节点）
static page_node_t *page_list_head = NULL;
static uint8_t current_page_id = 0; // 当前显示的页面ID

4.3 链表核心操作：注册 / 切换 / 销毁

1. 页面注册（将页面加入链表管理）

运行

复制代码

/**
 * @brief 注册页面到链表
 * @param page_id 页面唯一ID
 * @param create_func 页面创建函数
 * @param destroy_func 页面销毁函数
 * @return 0-成功，-1-失败
 */
int page_register(uint8_t page_id, page_create_cb create_func, page_destroy_cb destroy_func) {
    // 检查ID是否已存在（避免重复注册）
    page_node_t *tmp = page_list_head;
    while(tmp) {
        if(tmp->page_id == page_id) return -1;
    }

    // 申请链表节点内存（需检查是否申请成功）
    page_node_t *new_node = lv_mem_alloc(sizeof(page_node_t));
    if(new_node == NULL) return -1;

    // 初始化节点
    new_node->page_id = page_id;
    new_node->state = PAGE_STATE_UNUSED;
    new_node->page_obj = NULL;
    new_node->create_func = create_func;
    new_node->destroy_func = destroy_func;
    new_node->next = page_list_head;

    // 插入链表头部
    page_list_head = new_node;
    return 0;
}

2. 页面切换（核心：销毁旧页面 + 创建新页面）

运行

复制代码

/**
 * @brief 切换页面（杜绝内存泄漏的核心逻辑）
 * @param target_page_id 目标页面ID
 * @return 0-成功，-1-失败
 */
int page_switch(uint8_t target_page_id) {
    // 1. 查找旧页面（当前显示的页面）并销毁
    page_node_t *old_page = page_list_head;
    while(old_page) {
        if(old_page->page_id == current_page_id) {
            if(old_page->state != PAGE_STATE_UNUSED) {
                // 调用页面销毁函数（释放页面内所有子控件+资源）
                old_page->destroy_func(old_page->page_obj);
                // 清空页面句柄+重置状态
                old_page->page_obj = NULL;
                old_page->state = PAGE_STATE_UNUSED;
            }
            break;
        }
        old_page = old_page->next;
    }

    // 2. 查找目标页面并创建/显示
    page_node_t *new_page = page_list_head;
    while(new_page) {
        if(new_page->page_id == target_page_id) {
            // 调用页面创建函数
            new_page->create_func(&new_page->page_obj);
            if(new_page->page_obj == NULL) return -1;
            // 设置页面状态+更新当前页面ID
            new_page->state = PAGE_STATE_SHOWING;
            current_page_id = target_page_id;
            return 0;
        }
        new_page = new_page->next;
    }

    return -1; // 目标页面未注册
}

3. 页面销毁函数示例（必须释放所有子控件）

以 "首页" 为例，销毁函数需递归释放页面内所有 LVGL 对象：

运行

复制代码

// 首页创建函数
void home_page_create(lv_obj_t **page) {
    *page = lv_obj_create(lv_scr_act()); // 创建页面根对象
    // 创建页面内控件（按钮、文本、图片等）
    lv_obj_t *btn = lv_btn_create(*page);
    lv_obj_t *label = lv_label_create(btn);
    lv_label_set_text(label, "切换页面");
    // ... 其他控件创建
}

// 首页销毁函数（核心：递归释放所有子对象）
void home_page_destroy(lv_obj_t *page) {
    if(page == NULL) return;
    // 释放页面内所有子控件（LVGL内置函数，递归销毁）
    lv_obj_clean(page);
    // 销毁页面根对象
    lv_obj_del(page);
    // 手动释放动态资源（如图片缓存，可选）
    // lv_img_cache_invalidate_src(NULL);
}

4.4 单片机平台内存泄漏规避要点

链表节点内存管理：页面注销时需释放链表节点本身（lv_mem_free），避免链表节点泄漏；
状态校验：切换页面时先检查旧页面状态，避免重复销毁 / 创建；

LVGL 内存监控 ：启用 LVGL 内置的内存统计（LV_USE_MEM_MONITOR），实时查看内存占用：

运行

复制代码

// 打印LVGL内存使用情况
void lv_mem_monitor(void) {
    lv_mem_monitor_t mon;
    lv_mem_monitor(&mon);
    printf("LVGL内存使用：已用%dKB，剩余%dKB，最大块%dKB\n", 
           mon.total_size/1024, mon.free_size/1024, mon.free_biggest_size/1024);
}

五、Linux 平台：基于多进程的 LVGL 页面管理

5.1 Linux 平台特性

Linux 平台（如 ARM 板、x86 主机）支持多进程，进程间内存完全隔离 ------ 子进程退出时，操作系统会自动回收其所有内存（包括 LVGL 对象、堆内存），从根本上避免跨页面内存泄漏。

核心思路：一个页面对应一个子进程，主进程仅负责页面切换（销毁旧进程 + 启动新进程），子进程内独立初始化 LVGL 并渲染页面。

5.2 核心设计：多进程页面管理

1. 主进程：管理页面进程（创建 / 销毁 / 切换）

主进程通过fork()创建子进程，通过进程 ID（PID）追踪页面进程，切换页面时杀死旧进程（自动释放内存），启动新进程：

运行

复制代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include "lvgl/lvgl.h"

// 当前页面进程PID
static pid_t current_page_pid = -1;

/**
 * @brief 终止旧页面进程（确保资源释放）
 */
void kill_old_page_process(void) {
    if(current_page_pid > 0) {
        // 发送终止信号
        kill(current_page_pid, SIGTERM);
        // 等待子进程退出，避免僵尸进程
        waitpid(current_page_pid, NULL, 0);
        current_page_pid = -1;
    }
}

/**
 * @brief 启动新页面进程
 * @param page_id 目标页面ID
 * @return 0-成功，-1-失败
 */
int start_new_page_process(uint8_t page_id) {
    // 先终止旧进程
    kill_old_page_process();

    // 创建子进程
    pid_t pid = fork();
    if(pid < 0) {
        perror("fork failed");
        return -1;
    }

    // 子进程逻辑：初始化LVGL+渲染页面
    if(pid == 0) {
        switch(page_id) {
            case 1:
                home_page_process(); // 首页进程
                break;
            case 2:
                setting_page_process(); // 设置页进程
                break;
            default:
                exit(1);
        }
        exit(0); // 进程退出（释放所有内存）
    }

    // 主进程：记录当前页面PID
    current_page_pid = pid;
    return 0;
}

2. 子进程：LVGL 页面渲染（独立内存空间）

子进程内独立初始化 LVGL，页面退出时只需正常退出进程，操作系统会自动回收所有内存：

运行

复制代码

/**
 * @brief 首页子进程逻辑
 */
void home_page_process(void) {
    // 1. 初始化LVGL（Linux平台：帧缓冲/SDL后端）
    lv_init();
    lv_linux_fbdev_init(); // 帧缓冲后端（ARM板）/ lv_sdl_init（x86）
    lv_obj_t *scr = lv_scr_act();

    // 2. 创建页面控件（与单片机逻辑一致）
    lv_obj_t *page = lv_obj_create(scr);
    lv_obj_t *btn = lv_btn_create(page);
    lv_obj_t *label = lv_label_create(btn);
    lv_label_set_text(label, "Linux平台首页");

    // 3. 事件处理（如按钮触发页面切换：通知主进程）
    lv_obj_add_event_cb(btn, btn_switch_event, LV_EVENT_CLICKED, NULL);

    // 4. LVGL主循环
    while(1) {
        lv_timer_handler();
        usleep(5000); // 5ms
    }
}

/**
 * @brief 按钮事件：通知主进程切换页面
 */
void btn_switch_event(lv_event_t *e) {
    // 子进程通过管道/信号通知主进程切换页面
    kill(getppid(), SIGUSR1); // 向主进程发送自定义信号
}

5.3 Linux 平台内存泄漏规避要点

避免僵尸进程 ：主进程必须调用waitpid()等待子进程退出，否则子进程变为僵尸进程，占用进程表资源；
进程退出清理 ：子进程退出前可显式调用lv_deinit()，但即使不调用，操作系统也会回收内存；
内存泄漏检测 ：使用valgrind工具检测进程内内存泄漏（针对单个页面进程）：

bash

运行
复制代码
```
# 检测页面进程的内存泄漏
valgrind --leak-check=full ./lvgl_page_demo 1
```
进程间通信：页面切换的触发（如按钮点击）需通过信号 / 管道 / 消息队列通知主进程，避免子进程直接操作主进程资源。

六、内存泄漏检测通用方法

平台	检测工具 / 方法	核心作用
单片机	LVGL 内存监控（lv_mem_monitor）	实时查看 LVGL 内存占用 / 剩余
单片机	RTOS 内存统计（如 FreeRTOS 的 xPortGetFreeHeapSize）	查看系统堆内存剩余
Linux	valgrind --leak-check=full	精准定位进程内内存泄漏点
Linux	ps/top/free	监控进程内存占用变化

七、总结与最佳实践

7.1 核心总结

单片机平台 ：通过链表统一管理页面生命周期，切换页面时必须销毁旧页面的所有 LVGL 对象，确保 "创建 - 销毁" 闭环；
Linux 平台 ：利用多进程内存隔离特性，一个页面对应一个子进程，切换页面时终止旧进程（操作系统自动回收内存），从根本杜绝泄漏；
无论哪种平台，资源申请与释放必须成对出现，动态资源（图片 / 缓存）需显式释放，避免依赖 LVGL 自动回收。

7.2 最佳实践

所有页面实现统一的create/destroy接口，禁止直接在业务代码中创建未管理的 LVGL 对象；
单片机平台启用 LVGL 内存监控，定期打印内存使用情况，发现内存持续减少时及时排查；
Linux 平台优先使用多进程隔离，减少进程内资源管理复杂度；
开发阶段通过检测工具（valgrind/RTOS 内存统计）提前发现泄漏，避免上线后问题爆发。