內存泄漏會產生哪些后果
內存泄漏原因
內存泄漏在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?？梢杂脕韺崿Fhook。需要注意的是，我們實現的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;
}
方案二
使用宏定義, 開啟宏定義使用我們的版本，不開啟就使用系統的?？梢苑奖鉪ebug。
內存泄漏檢測使用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文章
96瀏覽量
24237 -
C++
+關注
關注
22文章
2104瀏覽量
73503 -
代碼
+關注
關注
30文章
4753瀏覽量
68368 -
內存泄漏
+關注
關注
0文章
39瀏覽量
9206
發布評論請先 登錄
相關推薦
內存泄漏定位該如何去實現呢
。對于內存泄漏的情況，如果一開始不做預防，定位內存泄漏就會相當繁瑣，定位也會很長，非常的耗時、耗力。這里可通過malloc、free的第二次
發表于 12-17 07:24
C++內存泄漏
C++內存分配與釋放均由用戶代碼自行控制，靈活的機制有如潘多拉之盒，即讓程序員有了更廣的發揮空間，也產生了代代相傳的內存泄漏問題。對于新手來說，最常
發表于 09-15 17:39
?16次下載
ThreadLocal發生內存泄漏的原因
，就可能會導致內存泄漏。下面，我們將圍繞三個方面來分析 ThreadLocal 內存泄漏的問題 ThreadLocal 實現原理 Threa
內存泄漏問題原理及檢視方法
可能不少開發者都遇到過內存泄漏導致的網上問題，具體表現為單板在現網運行數月以后，因為內存耗盡而導致單板復位現象。一方面，內存泄漏問題屬于比較
基于機器學習的內存泄漏測試腳本預測方法
用例通常需要運行數小時以上才能產生足以暴露泄漏的內存表現。整個測試過程代價高昂，若對測試用例不加篩選，可能會耗費大量的時間在暴露泄漏可能性低
發表于 05-07 10:23
?30次下載
Windows CE中的內存泄漏問題
很多實時嵌入式設備是長時間不間斷運行的，即使是少許的內存泄漏，也會積少成多，對嵌入式系統帶來災難性的影響。這幾天，我在嵌入式軟件項目中就飽嘗到這個痛苦，讓我明白到嵌入式實時系統的應用軟件也會有許多
什么是內存泄漏？內存泄漏有哪些現象
內存泄漏幾乎是很難避免的，不管是老手還是新手，都存在這個問題，甚至 Windows 與 Linux 這類系統軟件也或多或少存在著內存泄漏。
什么是內存泄漏？如何避免JavaScript內存泄漏
JavaScript 代碼中常見的內存泄漏的常見來源： 研究內存泄漏問題就相當于尋找符合垃圾回收機制的編程方式，有效避免對象引用的問題。
發表于 10-27 11:30
?363次閱讀
如何發現內存泄漏
由于 C 和 C++ 程序中完全由程序員自主申請和釋放內存，稍不注意，就會在系統中導入內存錯誤。同時，內存錯誤往往非常嚴重，一般會帶來諸如系統崩潰，
如何檢測內存泄漏
檢測內存泄漏是軟件開發過程中一項至關重要的任務，它有助于識別和解決那些導致程序占用過多內存資源，從而影響程序性能甚至導致程序崩潰的問題。以下將詳細闡述幾種常見的內存
工商網監
評論