内存泄漏原因

内存泄漏在C/C++这种不带GC(Garbage Collection)的语言里，是一个经常发生的问题。因为没有GC，所以分配的内存需要程序员自己调用释放。内存泄漏的根本原因是程序对于在申请的内存没有进行释放。

{
void *p1 = malloc(10);
void *p2 = malloc(20);

free(p1);
}

上面的代码段，申请了两块内存p1，p2，只释放了p1，没有释放p2，产生了内存泄漏。

内存泄漏会产生哪些后果？

随着程序运行时间越来越久，内存有分配没有释放，会使得进程堆中的内存会越来越少，直到耗尽。会造成后面的运行时代码不能成功分配内存。

内存泄漏如何解决？

方案一引入gc，从语言层面解决内存泄漏；

方案二当发生内存泄漏的时候，能够精准的定位代码那个文件、那个函数、哪一行所引起的。

我们实现的是方案二，核心需求有两个。

需求1：能够检测出内存泄漏

需求2：能够指出是由代码的哪个文件、哪个函数、哪一行引起的内存泄漏

内存泄漏检测如何实现？

内存泄漏检测实现的核心思想就是对系统的malloc/free进行hook，用我们自己的malloc/free代替系统调用，将free的地址和malloc的地址进行匹配，查看最后又哪些malloc没有进行free，并将没有free的malloc操作的代码段地址进行记录，通过代码段定位所在的文件、函数、代码行。

方案一

采用__libc_malloc, libc_free与__builtin_return_address。它们是gcc提供的函数。

__libc_malloc, libc_free用来代替malloc/free。可以用来实现hook。需要注意的是，我们实现的malloc/free函数，内部会有一些函数如printf，fopen，需要防止它们会嵌套调用malloc/free。

__builtin_return_address，能够返回调用所在函数的代码段的地址。能够定位内存泄漏的具体位置。

malloc的时候，创建一个文件，文件名使用申请内存的地址，并记录申请该内存的代码段的地址；free的时候，删除对应的文件。

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


int enable_malloc_hook = 1;
extern void *__libc_malloc(size_t size);

int enable_free_hook = 1;
extern void *__libc_free(void *p);

void *malloc(size_t size) {

    if (enable_malloc_hook) {
        enable_malloc_hook = 0;

        void *p = __libc_malloc(size);

        void *caller = __builtin_return_address(0);

        char buff[128] = {0};
        sprintf(buff, "./mem/%p.mem", p);

        FILE *fp = fopen(buff, "w");
        fprintf(fp, "[+%p]malloc -- > addr:%p size:%lun", caller, p, size);
        fflush(fp);

        enable_malloc_hook = 1;
        return p;
    } else {

        return __libc_malloc(size);

    }
    return NULL;
}

void free(void *p) {

    if (enable_free_hook) {
        enable_free_hook = 0;
        char buff[128] = {0};
        sprintf(buff, "./mem/%p.mem", p);

        if (unlink(buff) < 0) {
            printf("double free: %pn", p);
        }

        __libc_free(p);


        enable_free_hook = 1;
    } else {
        __libc_free(p);
    }

}

// gcc -o memleak_0 memleak_0.c -g
// addr2line -f -e  memleak_0  -a 0x4006d8
int main() {


    void *p1 = malloc(10);
    void *p2 = malloc(20);

    free(p1);

    void *p3 = malloc(30);
    void *p4 = malloc(40);

    free(p2);
    free(p4);

    return 0;

}

方案二

使用宏定义, 开启宏定义使用我们的版本，不开启就使用系统的。可以方便debug。

内存泄漏检测使用malloc_hook/free_hook, 定位内存泄漏位置，使用__FILE__, LINE .

#define malloc(size) malloc_hook(size, __FILE__, __LINE__)

#define free(p) free_hook(p, __FILE__, __LINE__)

可以使用fclose，没有double free的问题了

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

void *malloc_hook(size_t size, const char *file, int line) {

    void *p = malloc(size);

    char buff[128] = {0};
    sprintf(buff, "./mem/%p.mem", p);

    FILE *fp = fopen(buff, "w");
    fprintf(fp, "[+%s:%d]malloc -- > addr:%p size:%lun", file, line, p, size);
    fflush(fp);

    fclose(fp);

    return p;

}

void free_hook(void *p,  const char *file, int line) {

    char buff[128] = {0};
    sprintf(buff, "./mem/%p.mem", p);

    if (unlink(buff) < 0) {
        printf("double free: %pn", p);
        return;
    }

    free(p);

}

#define malloc(size)   malloc_hook(size, __FILE__, __LINE__)

#define free(p)    free_hook(p, __FILE__, __LINE__)


// gcc -o memleak_0 memleak_0.c -g
// addr2line -f -e  memleak_0  -a 0x4006d8
int main() {


    void *p1 = malloc(10);
    void *p2 = malloc(20);

    free(p1);

    void *p3 = malloc(30);   // memory leak
    void *p4 = malloc(40);

    free(p2);
    free(p4);
    free(p4); // double free

    return 0;

}

检测出两个问题，一次内存泄漏 p3，一次double free p4。结果OK。

方案三

使用malloc.h中提供的hook: __malloc_hook, __free_hook.

这两个hook，默认是malloc，free。

参考mtrace的做法，通过改变这两个值来进行检测。

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

typedef void *(*malloc_hoot_t)(size_t size, const void *caller);
malloc_hoot_t malloc_f;

typedef void (*free_hook_t)(void *p, const void *caller);
free_hook_t free_f;

void mem_trace(void);
void mem_untrace(void);

void *malloc_hook_f(size_t size, const void *caller) {

    mem_untrace();
    void *ptr = malloc(size);
    // printf("+%p: addr[%p]n", caller, ptr);
    char buff[128] = {0};
    sprintf(buff, "./mem/%p.mem", ptr);

    FILE *fp = fopen(buff, "w");
    fprintf(fp, "[+%p]malloc -- > addr:%p size:%lun", caller, ptr, size);
    fflush(fp);

    fclose(fp);

    mem_trace();
    return ptr;

}

void free_hook_f(void *p, const void *caller) {
    mem_untrace();
    // printf("-%p: addr[%p]n", caller, p);

    char buff[128] = {0};
    sprintf(buff, "./mem/%p.mem", p);

    if (unlink(buff) < 0) {
        printf("double free: %pn", p);
    }

    free(p);
    mem_trace();

}

void mem_trace(void) {

    malloc_f = __malloc_hook;
    free_f = __free_hook;

    __malloc_hook = malloc_hook_f;
    __free_hook = free_hook_f;
}

void mem_untrace(void) {

    __malloc_hook = malloc_f;
    __free_hook = free_f;

}


// gcc -o memleak_0 memleak_0.c -g
// addr2line -f -e  memleak_0  -a 0x4006d8
int main() {

    mem_trace();
    void *p1 = malloc(10);
    void *p2 = malloc(20);

    free(p1);

    void *p3 = malloc(30);
    void *p4 = malloc(40);

    free(p2);
    free(p4);
    mem_untrace();

    return 0;

}

方案四

使用mtrace

#include < stdlib.h >
#include < stdio.h >
#include < unistd.h >
#include < malloc.h >
#include < mcheck.h >

// gcc -o memleak_0 memleak_0.c -g
// addr2line -f -e  memleak_0  -a 0x4006d8
int main() {

// export MALLOC_TRACE=./test.log
    mtrace();
    void *p1 = malloc(10);
    void *p2 = malloc(20);

    free(p1);

    void *p3 = malloc(30);
    void *p4 = malloc(40);

    free(p2);
    free(p4);
    muntrace();

#endif
    return 0;

}

方案五

使用dlsym对malloc，free进行hook。

#define _GNU_SOURCE
#include < dlfcn.h >

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

typedef void *(*malloc_t)(size_t size);
malloc_t malloc_f;

typedef void (*free_t)(void *p);
free_t free_f;


int enable_malloc_hook = 1;

int enable_free_hook = 1;

void *malloc(size_t size) {

    if (enable_malloc_hook) {
        enable_malloc_hook = 0;

        void *p = malloc_f(size);

        void *caller = __builtin_return_address(0);

        char buff[128] = {0};
        sprintf(buff, "./mem/%p.mem", p);

        FILE *fp = fopen(buff, "w");
        fprintf(fp, "[+%p]malloc -- > addr:%p size:%lun", caller, p, size);
        fflush(fp);

        enable_malloc_hook = 1;
        return p;
    } else {

        return malloc_f(size);

    }
    return NULL;
}

void free(void *p) {

    if (enable_free_hook) {
        enable_free_hook = 0;
        char buff[128] = {0};
        sprintf(buff, "./mem/%p.mem", p);

        if (unlink(buff) < 0) {
            printf("double free: %pn", p);
        }

        free_f(p);


        enable_free_hook = 1;
    } else {
        free_f(p);
    }

}

static int init_hook() {

    malloc_f = dlsym(RTLD_NEXT, "malloc");

    free_f = dlsym(RTLD_NEXT, "free");

}

// gcc -o memleak_0 memleak_0.c -ldl -g
// addr2line -f -e  memleak_0  -a 0x4006d8
int main() {

    init_hook();

    void *p1 = malloc(10);
    void *p2 = malloc(20);

    free(p1);

    void *p3 = malloc(30);
    void *p4 = malloc(40);

    free(p2);
    free(p4);

    return 0;

}

共享内存

mmap方法1

匿名mmap

#include < stdio.h >
#include < sys/mman.h >
#include < unistd.h >



void *shm_mmap_alloc(int size) {

    void *addr = mmap(NULL, size, PROT_READ|PROT_WRITE, 
        MAP_ANON | MAP_SHARED, -1, 0);
    if (addr == MAP_FAILED) {
        return NULL;
    }

    return addr;

}

int shm_mmap_free(void *addr, int size) {

    return munmap(addr, size);

}


int main() {

    char *addr = (char *)shm_mmap_alloc(1024);

    pid_t pid = fork();
    if (pid == 0) {
        // child
        int i = 0;

        while(i < 26) {
            addr[i] = 'a' + i++;
            addr[i] = '�';
            sleep(1);
        }
    } else if (pid > 0) {
        int i = 0;
        while (i++ < 26) {
            printf("parent: %sn", addr);
            sleep(1);
        }
    }

    shm_mmap_free(addr, 1024);

}

mmap方法2

/dev/zero

#include < stdio.h >
#include < sys/mman.h >
#include < unistd.h >

#include < sys/types.h >
#include < sys/stat.h >
#include < fcntl.h >


void *shm_mmap_alloc(int size) {
    int fd = open("/dev/zero", O_RDWR);

    void *addr = mmap(NULL, size, PROT_READ|PROT_WRITE, 
        MAP_SHARED, fd, 0);
    close(fd);

    if (addr == MAP_FAILED) {
        return NULL;
    }

    return addr;

}

int shm_mmap_free(void *addr, int size) {

    return munmap(addr, size);

}


int main() {

    char *addr = (char *)shm_mmap_alloc(1024);

    pid_t pid = fork();
    if (pid == 0) {
        // child
        int i = 0;

        while(i < 26) {
            addr[i] = 'a' + i++;
            addr[i] = '�';
            sleep(1);
        }
    } else if (pid > 0) {
        int i = 0;
        while (i++ < 26) {
            printf("parent: %sn", addr);
            sleep(1);
        }
    }

    shm_mmap_free(addr, 1024);

}

shmget方法

#include < stdio.h >
#include < sys/mman.h >
#include < unistd.h >

#include < sys/types.h >
#include < sys/stat.h >
#include < fcntl.h >

#include < sys/types.h >
#include < sys/shm.h >


void *shm_alloc(int size) {

    int segment_id = shmget(IPC_PRIVATE, size,
                        IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
    char *addr = (char *)shmat(segment_id, NULL, 0);

    return addr;

}

int shm_free(void *addr) {

    return shmdt(addr);

}


int main() {

    char *addr = (char *)shm_alloc(1024);

    pid_t pid = fork();
    if (pid == 0) {
        // child
        int i = 0;

        while(i < 26) {
            addr[i] = 'a' + i++;
            addr[i] = '�';
            sleep(1);
        }
    } else if (pid > 0) {
        int i = 0;
        while (i++ < 26) {
            printf("parent: %sn", addr);
            sleep(1);
        }
    }

    shm_free(addr);

}

声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容侵权或者其他违规问题，请联系本站处理。举报投诉

语言

语言

+关注

关注
1

文章
97

浏览量
24249
C++

C++

+关注

关注
22

文章
2109

浏览量
73671
代码

代码

+关注

关注
30

文章
4790

浏览量
68649
内存泄漏

内存泄漏

+关注

关注
0

文章
39

浏览量
9218

内存泄漏定位该如何去实现呢

。对于内存泄漏的情况，如果一开始不做预防，定位内存泄漏就会相当繁琐，定位也会很长，非常的耗时、耗力。这里可通过malloc、free的第二次

发表于 12-17 07:24

C++内存泄漏

C++内存分配与释放均由用户代码自行控制，灵活的机制有如潘多拉之盒，即让程序员有了更广的发挥空间，也产生了代代相传的内存泄漏问题。对于新手来说，最常

发表于 09-15 17:39 •16次下载

ThreadLocal发生内存泄漏的原因

，就可能会导致内存泄漏。下面，我们将围绕三个方面来分析 ThreadLocal 内存泄漏的问题 ThreadLocal 实现原理 Threa

发表于 05-05 16:23 •3684次阅读

内存泄漏的特点和类型

在计算机科学中，内存泄漏（memory leak）指由于疏忽或错误使程序未能释放而造成不能再使用的内存的情况。内存泄漏并非指

发表于 06-20 10:58 •2827次阅读

内存泄漏问题原理及检视方法

可能不少开发者都遇到过内存泄漏导致的网上问题，具体表现为单板在现网运行数月以后，因为内存耗尽而导致单板复位现象。一方面，内存泄漏问题属于比较

发表于 10-10 10:42 •2557次阅读

基于机器学习的内存泄漏测试脚本预测方法

用例通常需要运行数小时以上才能产生足以暴露泄漏的内存表现。整个测试过程代价高昂，若对测试用例不加筛选，可能会耗费大量的时间在暴露泄漏可能性低

发表于 05-07 10:23 •30次下载

Windows CE中的内存泄漏问题

很多实时嵌入式设备是长时间不间断运行的，即使是少许的内存泄漏，也会积少成多，对嵌入式系统带来灾难性的影响。这几天，我在嵌入式软件项目中就饱尝到这个痛苦，让我明白到嵌入式实时系统的应用软件也会有许多

发表于 08-15 09:47 •1283次阅读

Windows CE中的<b class='flag-5'>内存</b><b class='flag-5'>泄漏</b>问题

什么是内存泄漏？内存泄漏有哪些现象

内存泄漏几乎是很难避免的，不管是老手还是新手，都存在这个问题，甚至 Windows 与 Linux 这类系统软件也或多或少存在着内存泄漏。

发表于 09-05 17:24 •9707次阅读

什么是内存泄漏？如何避免JavaScript内存泄漏

JavaScript 代码中常见的内存泄漏的常见来源：研究内存泄漏问题就相当于寻找符合垃圾回收机制的编程方式，有效避免对象引用的问题。

发表于 10-27 11:30 •400次阅读

什么是<b class='flag-5'>内存</b><b class='flag-5'>泄漏</b>？如何避免JavaScript<b class='flag-5'>内存</b><b class='flag-5'>泄漏</b>

内存泄漏如何避免

的数，那就是内存溢出。 2. 内存泄漏内存泄露 memory leak，是指程序在申请内存后，无法释放已申请的

发表于 11-10 11:04 •753次阅读

<b class='flag-5'>内存</b><b class='flag-5'>泄漏</b>如何避免

线程内存泄漏问题的定位

记录一个关于线程内存泄漏问题的定位过程，以及过程中的收获。 1. 初步定位是否存在内存泄漏：想到内存泄

发表于 11-13 11:38 •619次阅读

如何发现内存泄漏

由于 C 和 C++ 程序中完全由程序员自主申请和释放内存，稍不注意，就会在系统中导入内存错误。同时，内存错误往往非常严重，一般会带来诸如系统崩溃，

发表于 11-13 15:41 •605次阅读

内存溢出与内存泄漏：定义、区别与解决方案

内存溢出与内存泄漏：定义、区别与解决方案内存溢出和内存泄漏是计算机科学中常见的问题，在开发和

发表于 12-19 14:10 •2819次阅读

C语言内存泄漏问题原理

内存泄漏问题只有在使用堆内存的时候才会出现，栈内存不存在内存泄漏问题，因为栈

发表于 03-19 11:38 •530次阅读

如何检测内存泄漏

检测内存泄漏是软件开发过程中一项至关重要的任务，它有助于识别和解决那些导致程序占用过多内存资源，从而影响程序性能甚至导致程序崩溃的问题。以下将详细阐述几种常见的内存

发表于 07-30 11:50 •1926次阅读

搜索历史

内存泄漏会产生哪些后果