Fork me on GitHub

js的内存泄漏

发表于 | 分类于
字数统计: 2,287 | 阅读时长 ≈ 9
在任何程序设计环境及语言中，内存管理都十分重要。这篇文章来记录一下js的内存管理

内存泄漏

什么是内存泄漏

在计算机科学中，内存泄漏指由于疏忽或错误造成程序未能释放已经不再使用的内存。内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，导致在释放该段内存之前就失去了对该段内存的控制，从而造成了内存的浪费。

总结一下，用不到的或者失去控制权（没有变量或指针指向的）的内存，没有及时释放，就叫内存泄漏。

简单的例子

一个来自维基百科的例子：

在此例中的应用程序是一个简单软件的一小部分，用来控制升降机的运作。此部分软件当乘客在升降机内按下一楼层的按钮时运行。

当按下按钮时：

  1. 要求使用存储器，用作记住目的楼层

  2. 把目的楼层的数字储存到存储器中

  3. 升降机是否已到达目的楼层？

  4. 如是，没有任何事需要做：程序完成

  5. 否则：

    1. 等待直至升降机停止
    2. 到达指定楼层
    3. 释放刚才用作记住目的楼层的存储器

此程序有一处会造成存储器泄漏：如果在升降机所在楼层按下该层的按钮（即上述程序的第4步），程序将触发判断条件而结束运行，但存储器仍一直被占用而没有被释放。这种情况发生得越多，泄漏的存储器也越多。

这个小错误不会造成即时影响。因为人不会经常在升降机所在楼层按下同一层的按钮。而且在通常情况下，升降机应有足够的存储器以应付上百次、上千次类似的情况。不过，升降机最后仍有可能消耗完所有存储器。这可能需要数个月或是数年，所以在简单的测试下这个问题不会被发现。

而这个例子导致的后果会是不那么令人愉快。至少，升降机不会再理会前往其他楼层的要求。更严重的是，如果程序需要存储器去打开升降机门，那可能有人被困升降机内，因为升降机没有足够的存储器去打开升降机门。

存储器泄漏只会在程序运行的时间内持续。例如：关闭升降机的电源时，程序终止运行。当电源再度打开，程序会再次运行而存储器会重置，而这种缓慢的泄漏则会从头开始再次发生。

C 内存管理

没有内置自动垃圾回收的编程语言，如C及C++，必须手动释放内存，程序员负责内存管理。一般情况下，存储器泄漏发生是因为不能访问动态分配的存储器。

先看一下c语言的内存管理，C可以有静态和动态的内存管理。其中动态管理为了灵活分配和管理内存为c语言提供了几个函数。

函数 描述
void calloc(int num, int size); 该函数分配一个带有 function allocates an array of num 个元素的数组， 每个元素的大小为 size字节。
void free(void address); 该函数释放 address 所指向的h内存块。
void malloc(int num); 该函数分配一个 num 字节的数组，并把它们进行初始化。
void realloc(void *address, int newsize); 该函数重新分配内存，把内存扩展到 newsize。

对于预先不知道需要存储的文本长度，例如您向存储有关一个主题的详细描述。在这里，我们需要定义一个指针，该指针指向未定义所学内存大小的字符，后续再根据需求来分配内存，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
   char name[100];
   char *description;
   strcpy(name, "Zara Ali");
   /* 动态分配内存 */
   description = malloc( 200 * sizeof(char) );
   if( description == NULL )
   {
      fprintf(stderr, "Error - unable to allocate required memory\n");
   }
   else
   {
      strcpy( description, "Zara ali a DPS student in class 10th");
   }
   printf("Name = %s\n", name );
   printf("Description: %s\n", description );
}

也可以使用 calloc() 来编写，只需要把 malloc 替换为 calloc 即可，如下所示：

1
calloc(200, sizeof(char));

可以通过调用函数 realloc() 来增加或减少已分配的内存块的大小。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
   char name[100];
   char *description;
   strcpy(name, "Zara Ali");
   /* 动态分配内存 */
   description = malloc( 30 * sizeof(char) );
   if( description == NULL )
   {
      fprintf(stderr, "Error - unable to allocate required memory\n");
   }
   else
   {
      strcpy( description, "Zara ali a DPS student.");
   }
   /* 假设您想要存储更大的描述信息 */
   description = realloc( description, 100 * sizeof(char) );
   if( description == NULL )
   {
      fprintf(stderr, "Error - unable to allocate required memory\n");
   }
   else
   {
      strcat( description, "She is in class 10th");
   }
   printf("Name = %s\n", name );
   printf("Description: %s\n", description );
   /* 使用 free() 函数释放内存 */
   free(description);
}

当程序退出时，操作系统会自动释放所有分配给程序的内存，但是，建议您在不需要内存时，都应该调用函数 free() 来释放内存。

1
2
3
4
5
6
char * buffer;
buffer = (char*) malloc(42);
// Do something with buffer
free(buffer);

malloc方法用来申请内存，使用完毕之后，必须自己用free方法释放内存。

再举个c++的内存泄漏例子：

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
using namespace std;
int main()
{ 
   int *a = new int(123);
   cout << *a << endl;
   // We should write "delete a;" here
   a = new int(456);
   cout << *a << endl;
   delete a;
   return 0;
}

存储了整数123的内存空间不能被删除，因为地址丢失了。这些空间已无法再使用。

垃圾回收机制

类似c/c++这样的语言需要程序员自己来负责内存管理，这样很麻烦，所以大多数语言提供自动内存管理，减轻程序员的负担，这被称为”垃圾回收机制”。

垃圾回收机制怎么知道，哪些内存不再需要呢？

最常使用的方法叫做”引用计数”（reference counting）：语言引擎有一张”引用表”，保存了内存里面所有的资源（通常是各种值）的引用次数。如果一个值的引用次数是0，就表示这个值不再用到了，因此可以将这块内存释放。

引用计数

上图中，左下角的两个值，没有任何引用，所以可以释放。

如果一个值不再需要了，引用数却不为0，垃圾回收机制无法释放这块内存，从而导致内存泄漏。

1
2
const arr = [1, 2, 3, 4];
console.log('hello world');

上面代码中，数组[1, 2, 3, 4]是一个值，会占用内存。变量arr是仅有的对这个值的引用，因此引用次数为1。尽管后面的代码没有用到arr，它还是会持续占用内存。

如果增加一行代码，解除arr对[1, 2, 3, 4]引用，这块内存就可以被垃圾回收机制释放了。

1
2
3
let arr = [1, 2, 3, 4];
console.log('hello world');
arr = null;

上面代码中，arr重置为null，就解除了对[1, 2, 3, 4]的引用，引用次数变成了0，内存就可以释放出来了。

因此，并不是说有了垃圾回收机制，程序员就轻松了。你还是需要关注内存占用：那些很占空间的值，一旦不再用到，你必须检查是否还存在对它们的引用。如果是的话，就必须手动解除引用。

内存泄漏的识别方法

利用浏览器

Chrome 浏览器查看内存占用

Chrome

  1. 打开开发者工具，选择 Performance 面板 (以前叫timeline)

  2. 在顶部的Capture字段里面勾选 Memory

  3. 点击左上角的录制按钮。

  4. 在页面上进行各种操作，模拟用户的使用情况。

  5. 一段时间后，点击对话框的 stop 按钮，面板上就会显示这段时间的内存占用情况。

如果内存占用基本平稳，接近水平，就说明不存在内存泄漏。

反之，就是内存泄漏了。

WeakMap

ES6推出了两种新的数据结构：WeakSet 和 WeakMap。它们对于值的引用都是不计入垃圾回收机制的，所以名字里面才会有一个”Weak”，表示这是弱引用。

1
2
3
4
5
6
const wm = new WeakMap();
const element = document.getElementById('example');
wm.set(element, 'some information');
wm.get(element) // "some information"

上面代码中，先新建一个 Weakmap 实例。然后，将一个 DOM 节点作为键名存入该实例，并将一些附加信息作为键值，一起存放在 WeakMap 里面。这时，WeakMap 里面对element的引用就是弱引用，不会被计入垃圾回收机制。

也就是说，DOM 节点对象的引用计数是1，而不是2。这时，一旦消除对该节点的引用，它占用的内存就会被垃圾回收机制释放。Weakmap 保存的这个键值对，也会自动消失。

基本上，如果你要往对象上添加数据，又不想干扰垃圾回收机制，就可以使用 WeakMap。

参考资料

JavaScript 内存泄漏教程

How JavaScript works: memory management

undefined