内存释放的问题？

[tclsnow]

程序如下
cout << "------------After 5Seconds start-------------" << endl;
sleep(5);
cout << "------------create Packet start-------------" << endl;
list<char*> charList;
for (int i = 0; i<1000000; i++) {
char* xx = new char[1024];
if (i%200000 == 0) {
cout << "------Now create-------" <<i << endl;
sleep(2);
}

charList.push_back(xx);
}
cout << "------------create Packet finish-------------" << endl;


sleep(20);


cout << "------------delete Packet start-------------" << endl;
list<char*>::iterator it = charList.begin();
int n = 0;
while (it != charList.end()) {
n ++;
delete[] *it;

it ++;
}
cout << "------------delete Packet finish-------------" << n << endl;

sleep(20);
cout << "------------exit-------------" << endl;

执行前内存如下
Mem: 1034420k total, 69592k used, 964828k free, 4264k buffers
Swap: 2031608k total, 56184k used, 1975424k free, 31312k cached


打印完"------------create Packet finish-------------"
之后内存如下
Mem: 1034420k total, 1011132k used, 23288k free, 188k buffers
Swap: 2031608k total, 117024k used, 1914584k free, 11960k cached


打印完 "------------delete Packet finish-------------"
之后内存如下
Mem: 1034420k total, 1018364k used, 16056k free, 92k buffers
Swap: 2031608k total, 633204k used, 1398404k free, 9544k cached

可以说内存根本就没被释放掉，不知道为什么，

请高人指点！谢谢！

[tclsnow]

当然不可以了，我都试验了，如果分配在多的话，系统就把这个进程杀掉。
关键是
list<char*>::iterator it = charList.begin();
int n = 0;
while (it != charList.end()) {
n ++;
delete[] *it;

it ++;
}
这部分有问题，但我找不出来！
请高人指点！

[gxqcn]

charList 本身要占用大量内存，将它清空后再看看？

[tclsnow]

charList 占用很小一部分内存的。他只是存放指针，

[gxqcn]

1000000 个节点的 list 可不是小数目啊。。。

[珍惜生命远离CPP]

1000000*1024;呃已经1G内存了,你的系统允许你的程序分配1G内存么?
char* xx[100*1024];
//这段代码运行N次,看看如果超过100M 以上就说明内存没释放掉,如果始终在100M左右,那就是正常现象.
for( int x = 0 ; x < 100*1024; x++){
xx[x]=new char[1024];
}
for( int x = 0 ; x < 100*1024; x++){
delete xx[x];
xx[x]=0;
}

占用内存 大,是正常现象.释放的内存不会立即归还给操作系统的,在下次分配的时候会从这些释放的内存中重新分配.所以程序会占用大量的内存.

[珍惜生命远离CPP]

你用系统提供的分配内存api来分配释放内存看看.

[jixingzhong]

内存的分配如果每次都直接和系统交互，
效率是很低下的 ...

所以，
一般会有一个策略，
一次分配一块内存，
然后在这块内存上进行分割需要的部分，剩余的留下后续的申请使用；
当这块内存还是不够的时候，再申请一块内存，（可能会增加块的大小）
...

而这些块，
在程序运行期间，你可以“释放”，但是这个“释放”是不还给系统的，
它们可以被重新分配使用，但是只在程序范围内可用。
只有在程序结束后才归还给系统。

[jixingzhong]

看看 Allocater ...

它就是分配器，
其中封装了内存管理细节，即如何分配这个块，如何管理这个块。
一般都使用STL默认提供的 Allocater ，
但是你也可以自己实现一个，
并以参数的形式提供给 STL 容器。

[jixingzhong]

一个简单的例子：

【Ref】
template<typename T>
class Allocator {
public :
// typedefs
typedef T value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;

public :
// convert an allocator<T> to allocator<U>
template<typename U>
struct rebind {
typedef Allocator<U> other;
};

public :
inline explicit Allocator() {}
inline ~Allocator() {}
inline explicit Allocator(Allocator const&) {}
template<typename U>
inline explicit Allocator(Allocator<U> const&) {}

// address
inline pointer address(reference r) { return &r; }
inline const_pointer address(const_reference r) { return &r; }

// memory allocation
inline pointer allocate(size_type cnt,
typename std::allocator<void>::const_pointer = 0) {
return reinterpret_cast<pointer>(::operator new(cnt * sizeof (T)));
}
inline void deallocate(pointer p, size_type) {
::operator delete(p);
}

// size
inline size_type max_size() const {
return std::numeric_limits<size_type>::max() / sizeof(T);
}

// construction/destruction
inline void construct(pointer p, const T& t) { new(p) T(t); }
inline void destroy(pointer p) { p->~T(); }

inline bool operator==(Allocator const&) { return true; }
inline bool operator!=(Allocator const& a) { return !operator==(a); }
}; // end of class Allocator

看看这个页面吧：
http://gcc.gnu.org/onlinedocs/libstdc++/20_util/allocator.html

[tclsnow]

我的系统是两G的内存，分配这些一点问题没有，是IBM brade server。
不过我分配完内存，马上释放就没问题。是不是和list有关系。

[tclsnow]

我都烦死了，执行了72小时的程序，然后就没内存了。然后调查，发现内存泄漏。
执行工具那个机器更爽，HA8000，4cpu, 8G内存。好机器也白搭了，程序烂阿！
还有其他解决办法么？

[tclsnow]

cout << "------------000-------------" << endl;

char* xx[1000*1024];

for( int x=0; x<1000*1024; x++){
xx[x] = new char[1024];

if (x% (50 * 1024) == 0) {
cout << "------Now create-------" <<x << endl;
sleep(2);
}
}

cout << "------------111-------------" << endl;
sleep(10);

for( int x=0; x<1000*1024; x++){
delete xx[x];
xx[x]=0;
}

cout << "------------222-------------" << endl;
sleep(10);
cout << "------------333-------------" << endl;
sleep(10);

我执行了，内存被释放了。
执行前
Mem: 1034420k total, 44360k used, 990060k free, 624k buffers
Swap: 2031608k total, 56568k used, 1975040k free, 15724k cached

打印"------------111-------------" 之后内存
Mem: 1034420k total, 1018460k used, 15960k free, 348k buffers
Swap: 2031608k total, 125492k used, 1906116k free, 10684k cached

打印"------------222-------------" 之后内存
Mem: 1034420k total, 41444k used, 992976k free, 84k buffers
Swap: 2031608k total, 59556k used, 1972052k free, 8108k cached
为什么放到list里之后就释放不了呢？
纳闷！

[星羽]

蹭

[taodm]

看《STL源码剖析》看STL的内存管理策略了。
解决方案：自己接管allocator

[Inhibitory]

可能是list的与内存分配的问题,以前我用int型的数组,分配了2G内存,程序退出前释放内存,能正确翻译.

[Inhibitory]

#include <iostream>
#include <cstdio>
#include <ctime>
#include <cmath>
#include <list>

using namespace std;

int main(int arg, char** argv) {
list<double*> lists(100000);
try {
for (int i = 0; i < 100000; i++) {
double* pTemp = new double[10000];
lists.push_back(pTemp);
}
} catch (bad_alloc e) {
cout << "Memory allocated false." << endl;
cin.get(); // 这时,看任务管理器,内存占用了2500M左右
list<double*>::iterator it;
for (it = lists.begin(); it != lists.end(); it++) {
if (*it != NULL) {
delete[] (*it);
*it = NULL;
}
}
}

system("pause");

list<double*>::iterator it;
for (it = lists.begin(); it != lists.end(); it++) {
if (*it != NULL) {
delete[] (*it);
}
}

return 0;
}
// 程序结束,任务管理器显示内存又回到了500M左右

又试了一下,用STL的list能正确分配与释放内存, 可能是你的程序分配大量内存时由于内存不够而发生异常,而没有把已经分配到的内存释放.

[dai_weitao]

你的while循环有问题, 只释放了一个结点, 应该释放it前面的结点.

[redex]

同意: dai_weitao(疯狂Linux C++)的说法.

[liuhaoran]

呵呵,很奇怪,我只是把list改成vector就好了,内存就成功给释放了,但list不可以....

[feimingbiao]

楼主我对你的测试结果有点儿怀疑，你 new 的时候是在Process的Default Heap，Process没有结束前，你的Delete只是把他们还给了这个Heap，对于系统来讲，你的Process Memory不见得变少了。释放的那些内存只不过又加回到了Free List里面。你可以用HeapSize（GetProcessHeap(),x,x)看看那些东西到底释放了没有。还有GetProcessMemoryInfo的数据更可信些。