c mysql 内存泄露_C指针原理教程之垃圾回收-内存泄露

最新推荐文章于 2023-03-08 20:34:27 发布
最新推荐文章于 2023-03-08 20:34:27 发布
阅读量83 收藏
点赞数
文章标签： c mysql 内存泄露
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39638623/article/details/114488523
版权

一、内存泄露

1、正常的链表操作

下面程序建立一个10元素的链表，输出它们的节点，每个节点是一个员工的工号和年龄。最后删除每个节点，释放列表。

dp@dp:~/memorytest % cat 1.c

#include

#include

//code:myhaspl@myhaspl.com

//author:myhaspl

//date:2014-01-10

typedef struct listnode mynode;

struct listnode{

mynode *next;

int number;

int age;

};

mynode *addnode(mynode *prevnd,int number,int age){

mynode *ndtemp=(mynode*)malloc(sizeof(mynode));

prevnd->next=ndtemp;

ndtemp->number=number;

ndtemp->age=age;

ndtemp->next=NULL;

return ndtemp;

}

mynode *initlist(){

mynode *temp=(mynode*)malloc(sizeof(mynode));

temp->number=0;

temp->age=0;

temp->next=NULL;

return temp;

}

int main(){

mynode *mylist=initlist();

mynode *mytempnd=mylist;

int i=0;f悬挂指针

for(i=0;i<10;i++){

mytempnd=addnode(mytempnd,i,20+i);

}

//下面是正常的链表操作

//先输出链表元素

for (mytempnd=mylist->next;mytempnd!=NULL;mytempnd=mytempnd->next){

printf("id:%d,age:%d\n",mytempnd->number,mytempnd->age);

}

//然后删除链表中的所有元素

mynode* oldtmpnd;

for (mytempnd=mylist->next;mytempnd!=NULL;){

printf("delete id:%d\n",mytempnd->number);

oldtmpnd=mytempnd;

mytempnd=mytempnd->next;

free(oldtmpnd);

}

free(mylist);

return 0;

}

下面是程序运行效果

dp@dp:~/memorytest % gcc 1.c -o mytest

dp@dp:~/memorytest % ./mytest

id:0,age:20

id:1,age:21

id:2,age:22

id:3,age:23

id:4,age:24

id:5,age:25

id:6,age:26

id:7,age:27

id:8,age:28

id:9,age:29

delete id:0

delete id:1

delete id:2

delete id:3

delete id:4

delete id:5

delete id:6

delete id:7

delete id:8

delete id:9

dp@dp:~/memorytest %

下面演示了垃圾的形成，这是内存泄露的一种方式，即在链表中，某些节点与链表中的其它节点失去联系，导致无法删除，下面故意让第4个结点的next指针指向null，失去与后面6个元素的联系。

dp@dp:~/memorytest % cat 1.c

#include

#include

//code:myhaspl@myhaspl.com

//author:myhaspl

//date:2014-01-10

typedef struct listnode mynode;

struct listnode{

mynode *next;

int number;

int age;

};

mynode *addnode(mynode *prevnd,int number,int age){

mynode *ndtemp=(mynode*)malloc(sizeof(mynode));

prevnd->next=ndtemp;

ndtemp->number=number;

ndtemp->age=age;

ndtemp->next=NULL;

return ndtemp;

}

mynode *initlist(){

mynode *temp=(mynode*)malloc(sizeof(mynode));

temp->number=0;

temp->age=0;

temp->next=NULL;

return temp;

}

int main(){

mynode *mylist=initlist();

mynode *mytempnd=mylist;

int i=0;

for(i=0;i<10;i++){

mytempnd=addnode(mytempnd,i,20+i);

}

//下面是正常的链表操作

//先输出链表元素

for (mytempnd=mylist->next;mytempnd!=NULL;mytempnd=mytempnd->next){

printf("id:%d,age:%d\n",mytempnd->number,mytempnd->age);

}

//然后删除链表中的所有元素

for (mytempnd=mylist->next;mytempnd!=NULL;mytempnd=mytempnd->next){

printf("delete id:%d\n",mytempnd->number);

free(mytempnd);

}

free(mylist);

//下面是形成内存泄露第一种情况-垃圾的演示

//生成并输出链表，这个与前面相同

mylist=initlist();

mytempnd=mylist;

i=0;

for(i=0;i<10;i++){

mytempnd=addnode(mytempnd,i,20+i);

}

for (mytempnd=mylist->next;mytempnd!=NULL;mytempnd=mytempnd->next){

printf("id:%d,age:%d\n",mytempnd->number,mytempnd->age);

}

//删除链表，我们故意留下后面6个链表节点无法删除，导致后面6个链表节点形成垃圾

int j=0;

for (mytempnd=mylist->next;mytempnd!=NULL;mytempnd=mytempnd->next){

if (++j>3){

mytempnd->next=NULL;

break;

}

}

for (mytempnd=mylist->next;mytempnd!=NULL;mytempnd=mytempnd->next){

printf("delete id:%d\n",mytempnd->number);

free(mytempnd);

j++;

}

return 0;

}

下面是程序运行效果

dp@dp:~/memorytest % gcc 1.c -o mytest

dp@dp:~/memorytest % ./mytest

id:0,age:20

id:1,age:21

id:2,age:22

id:3,age:23

id:4,age:24

id:5,age:25

id:6,age:26

id:7,age:27

id:8,age:28

id:9,age:29

delete id:0

delete id:1

delete id:2

delete id:3

delete id:4

delete id:5

delete id:6

delete id:7

delete id:8

delete id:9

id:0,age:20

id:1,age:21

id:2,age:22

id:3,age:23

id:4,age:24

id:5,age:25

id:6,age:26

id:7,age:27

id:8,age:28

id:9,age:29

delete id:0

delete id:1

delete id:2

delete id:3

dp@dp:~/memorytest %

3、悬挂指针

一个指针不为空，但是指向一个无效的地址或耒知对象的地址，则这样的指针称为悬挂指针。

dp@dp:~/memorytest % cat 2.c

#include

#include

//code:myhaspl@myhaspl.com

//author:myhaspl

//date:2014-01-10

typedef struct listnode mynode;

struct listnode{

mynode *next;

int number;

int age;

};

mynode *addnode(mynode *prevnd,int number,int age){

mynode *ndtemp=(mynode*)malloc(sizeof(mynode));

prevnd->next=ndtemp;

ndtemp->number=number;

ndtemp->age=age;

ndtemp->next=NULL;

return ndtemp;

}

mynode *initlist(){

mynode *temp=(mynode*)malloc(sizeof(mynode));

temp->number=0;

temp->age=0;

temp->next=NULL;

return temp;

}

int main(){

mynode *mylist=initlist();

mynode *mytempnd=mylist;

int i=0;

for(i=0;i<10;i++){

mytempnd=addnode(mytempnd,i,20+i);

}

//下面是正常的链表操作

//先输出链表元素

for (mytempnd=mylist->next;mytempnd!=NULL;mytempnd=mytempnd->next){

printf("id:%d,age:%d\n",mytempnd->number,mytempnd->age);

}

//然后删除链表中的所有元素

mynode* oldtmpnd;

for (mytempnd=mylist->next;mytempnd!=NULL;){

printf("delete id:%d\n",mytempnd->number);

oldtmpnd=mytempnd;

mytempnd=mytempnd->next;

free(oldtmpnd);

}

free(mylist);

//下面是形成内存泄露第二种情况-悬挂指针的演示

//生成并输出链表，这个与前面相同

mylist=initlist();

mytempnd=mylist;

i=0;

for(i=0;i<10;i++){

mytempnd=addnode(mytempnd,i,20+i);

}

for (mytempnd=mylist->next;mytempnd!=NULL;mytempnd=mytempnd->next){

printf("id:%d,age:%d\n",mytempnd->number,mytempnd->age);

}

//我们故意删除链表后面的4个节点，但是让第6个元素的next指向的地址无效，

//仍指向已经删除的第7个节点，导致悬挂指针

printf ("-------------------------\n");

int j=0;

for (mytempnd=mylist->next;mytempnd!=NULL;){

oldtmpnd=mytempnd;

mytempnd=mytempnd->next;

if (++j>6){

printf("delete id:%d\n",oldtmpnd->number);

free(oldtmpnd);

}

}

return 0;

}

执行程序

dp@dp:~/memorytest % gcc 2.c -o mytest

dp@dp:~/memorytest % ./mytest

id:0,age:20

id:1,age:21

id:2,age:22

id:3,age:23

id:4,age:24

id:5,age:25

id:6,age:26

id:7,age:27

id:8,age:28

id:9,age:29

delete id:0

delete id:1

delete id:2

delete id:3

delete id:4

delete id:5

delete id:6

delete id:7

delete id:8

delete id:9

id:0,age:20

id:1,age:21

id:2,age:22

id:3,age:23

id:4,age:24

id:5,age:25

id:6,age:26

id:7,age:27

id:8,age:28

id:9,age:29

delete id:6

delete id:7

delete id:8

delete id:9

但是注意free函数表示释放，这个释放指的是把这段内存标记成可用状态，或者说，没有人在用这段内存了，也就是意味着如果这段内存如果没有被操作系统重新使用，里面的数据还存在，如果被操作系统分配给其它程序或本程序的其它内存块申请之用，则数据会被清空。

3、下面是形成内存泄露第三种情况-共享的演示，多个指针指向同一个内存，这个内存因为某个指针不再使用的原因删除，导致其它指针指向一个无效地址

dp@dp:~/memorytest % cat 2.c

#include

#include

//code:myhaspl@myhaspl.com

//author:myhaspl

//date:2014-01-10

typedef struct listnode mynode;

struct listnode{

mynode *next;

char *data;

int number;

int age;

};

mynode *addnode(mynode *prevnd,int number,int age,char *data){

mynode *ndtemp=(mynode*)malloc(sizeof(mynode));

prevnd->next=ndtemp;

ndtemp->number=number;

ndtemp->age=age;

ndtemp->data=data;

ndtemp->next=NULL;

return ndtemp;

}

mynode *initlist(){

mynode *temp=(mynode*)malloc(sizeof(mynode));

temp->number=0;

temp->age=0;

temp->data=NULL;

temp->next=NULL;

return temp;

}

int main(){

//下面是形成内存泄露第三种情况-共享的演示，多个指针指向同一个内存，这个内存因为某个指针不再使用的原因删除，

//生成并输出链表，生成1个链表(共3个元素)，元素的data都指向同一个内存块

mynode *mylist=initlist();

mynode *mytempnd=mylist;

char *mydata=(char *)malloc(100);

const char *strsrc="helloworld";

strcpy(mydata,strsrc);

int i=0;

for(i=0;i<3;i++){

mytempnd=addnode(mytempnd,i,20+i,mydata);

}

for (mytempnd=mylist->next;mytempnd!=NULL;mytempnd=mytempnd->next){

printf("id:%d,age:%d,data:%s\n",mytempnd->number,mytempnd->age,mytempnd->data);

}

//下面将导致共享的内存释放，但仍有2个结点指向这个内存，这将导致内存泄露

//我们故意删除最后一个节点，并释放最后一个结点的data指针指向的内存

printf ("-------------------------\n");

mynode *oldtmpnd;

for (mytempnd=mylist->next;mytempnd!=NULL;){

oldtmpnd=mytempnd;

mytempnd=mytempnd->next;

if (mytempnd==NULL){

printf("delete id:%d\n",oldtmpnd->number);

free(oldtmpnd->data);

free(oldtmpnd);

}

}

return 0;

}

执行程序：

dp@dp:~/memorytest % gcc 2.c -o mytest

2.c: In function 'main':

2.c:37: warning: incompatible implicit declaration of built-in function 'strcpy'

dp@dp:~/memorytest % ./mytest

id:0,age:20,data:helloworld

id:1,age:21,data:helloworld

id:2,age:22,data:helloworld

delete id:2

dp@dp:~/memorytest %

mysql-boost-5.7.24.tar.gz
12-22
1. **智能指针**：例如`shared_ptr`和`unique_ptr`，提供垃圾回收机制，防止内存泄漏。 2. **多线程**：提供了线程管理、同步原语，如mutexes和condition variables，方便编写多线程程序。 3. **函数对象**：包括`...
记一次mysql内存泄漏排查经历
I'm Baymax D
05-20 2416
记一次艰难的mysql数据库内存泄漏排查经历，以供以后类似问题参考。
MySQL内存泄漏
weixin_42590246的博客
03-08 1086
MySQL内存泄漏
mysql内存泄露_MySQL关于内存泄漏与内存分配最佳实践
weixin_39637646的博客
01-19 1271
MySQL关于内存泄漏现象&猜测原因最近发现新上的项目数据库服务器一直报可用内存不足，OS版本：Centos Linux release 7.6.1810，内核版本：3.10.0-957.el7.x86_64，MySQL版本：5.7.28&5.7.29。排查一圈应该是内存泄漏了。加上前几日爱可生开源社区的关于内存泄漏的文章，和叶老板的支持，怀疑2个方面：1.P_S；2.table_...
翻译| 如何排查MySQL 内存泄漏
杨建荣的学习笔记
10-06 667
Troubleshooting对crash的数据库进行故障分析并不是一件快乐的事情，尤其是 MySQL 的日志中没有提供 crash 原因的情形。比如当 MySQL 内存耗尽。在 201...
MySQL 内存问题排查思路
u012565458的博客
10-10 2589
简介：MySQL 内存持续增长的问题虽然不会经常发生，但是如果偶尔发生了，也会让我们不知所措。一 、如果碰到MySQL 内存持续升高问题的主要情况有4种：MySQL 没有合理设置 innodb_buffer_pool_size服务器上还有一些其他进程可以分配内内存。MySQL 内存泄漏。内存缓慢增长属于正常现象，但存在因为一些慢sql频繁执行并因MySQL的内存分配使用了系统glibc，而glibc本身的内存分配算法存在缺陷，导致内存释放不完全。二、MySQL 内存持续排查思路： 1 基于服务器的检查：
使用c语言实现一个简单的数据库功能.zip
最新发布
06-14
5. **内存管理**：C语言没有自动垃圾回收，因此需要手动管理内存。使用`malloc`和`free`分配和释放内存。数据库操作可能会涉及大量内存操作，所以要特别注意内存泄漏和悬挂指针的问题。 6. **并发控制**：如果考虑...
零蛋内存遍历工具 V0.3 修正版 by Jesses
12-17
3. **内存分析**：分析内存中的异常情况，如空指针、内存泄漏、越界访问等。 4. **安全风险**：内存遍历可能会暴露敏感信息，因此在进行此类操作时应谨慎，并遵循最小权限原则。 5. **内存保护机制**：理解操作系统...
基于C++的MySQL数据库连接池源代码
03-27
在C++中实现MySQL数据库连接池，通常会使用MySQL的C API，这是一个提供与MySQL服务器通信的C语言接口。首先，我们需要包含必要的头文件，如`mysql.h`，并确保已经正确安装了MySQL的开发库。接下来，我们可以设计一个...
关于使用MYSQL出现的内存泄漏问题
william9987的博客
07-15 1095
最近做的东西使用了MySql做查询排序等，但是一直出现问题，主要是出现在查询的时候内存总是在增加，每次增加的内存大小是一样的， 找了很多资料才知道原来是使用了mysql_store_result()后忘了释放： 　　所以，记住由mysql_store_result()、mysql_use_result()、mysql_list_dbs()的结果集在完成对结果集的操作后，必须调用mysql_free_result()释放结果集使用的内存。 　　还有，每次查询返回的结果的地址是不一样的，所以必须释放。
记一次mysql内存泄露
liuzhilong的博客
03-05 480
监控告警某mysql实例内存使用率85%，而且在一点点的往上长 实例分配内存130G 登陆数据库show engine innodb status\G buffer pool使用约98G，占总内存的73%作业，还有10几%未知 ---------------------- BUFFER POOL AND MEMORY ---------------------- Total large memory allocated 105545465856 --98G Dictionary mem...
MySQL C API造成内存泄漏
Thinkcortex的博客
10-11 2268
使用C操作MySQL，程序完成时使用Valgrind检测，发现有内存泄漏。 ==4785== LEAK SUMMARY: ==4785== definitely lost: 0 bytes in 0 blocks ==4785== indirectly lost: 0 bytes in 0 blocks ==4785== possibly lost: 0 bytes in
MySQL C API的内存泄露问题
bollaxu的专栏
01-10 267
程序使用MySQL的C API比较频繁，在检查程序内存泄露的时候，想到了API里面会不会有内存泄露的问题。网上说mysql api在使用的时候会出现泄露，有人用了valgrind来测试，找到了可能出现泄露的地方，官方的api文档里面也说到，如果使用完api之后，最好调用mysql_library_end()函数来释放内存。   mysql api的官方建议，如果是多线程的时候，最好是在创建线程...
golang mysql 泄漏_连接mysql有内存泄漏？
weixin_35854529的博客
01-19 352
各位大牛，求帮忙！问题描述：1,并发10条请求，database/sql 连接池打开10个mysql连接，执行结束后，连接关闭，但内存不回收。2,如果继续第1步，内存不会上升。3,继续并发20条请求，则内存会再上升。4,继续并发请求，如果并发数大于20,则内存上升，如果并发数小于20,则内存不会上升。5,内存上升后，不会下降。代码：```gopackage mainimport ("databas...
MySQL C 客户端的内存泄漏问题
weixin_34183910的博客
05-05 240
我们的一个服务器软件在线上环境运行时出现了内存缓慢增长的问题。 用valgrind测试 MySQL的C客户端mysqlclient发现，它在正常的使用中会被valgrind报出存在内存泄漏。 1 正常使用场景 下面的代码是使用mysqlclient读取数据的最常用的代码 #include &lt;mysql/mysql.h&gt; #include &lt;stdio.h&g...
c mysql 内存_c代码连接mysql数据库内存泄露的问题
weixin_35928736的博客
01-19 145
一直使用C代码连接mysql数据库，今天用valgrind检测，发现存在内存泄露的问题代码如下MYSQL*connection;connection=mysql_init();connection=mysql_real_connect(connection，......);mysql_query(.........);mysql_close(connection);在网上查了一番，找到如下解决方案...
C++11实现MySQL连接池的读书笔记
- 资源泄露防范：需要有机制确保数据库连接在发生异常时能够被正确关闭，避免内存泄露。 - 线程安全：多线程环境下，连接池的实现需要保证线程安全，避免连接状态的冲突和数据不一致。 5. 基于C++11实现MySQL连接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值