Nodejs学习--本地句柄等概念理解

牛刀杀鸡牛刀杀鸡 - 2023-03-26 15:11:12

---

1. 在C++层间解释下Local和persistent

Local 和 persistent 都是在 C++ 层面上用于管理异步 I/O 操作的句柄。其中，Local 句柄是一种临时的句柄，用于处理一次性的 I/O 操作，比如读取一个文件或者发送一个网络请求。Local 句柄在 I/O 操作完成后会自动关闭，因此不需要手动释放资源。persistent 句柄则是一种长期存在的句柄，用于处理需要持续监听的 I/O 操作，比如监听一个网络端口或者一个文件的变化。persistent 句柄需要手动释放资源，否则会导致内存泄漏。在 Node.js 中，Local 和 persistent 句柄都是通过 node::ObjectWrap 类来实现的。具体来说，可以通过继承 node::ObjectWrap 类来创建一个自定义的 Local 或 persistent 句柄类，然后在类的构造函数中调用 Wrap() 方法来将 C++ 对象绑定到 JavaScript 对象上。在 JavaScript 层面上，可以通过 new 关键字来创建一个 Local 或 persistent 句柄对象，然后调用对象的方法来进行异步 I/O 操作。

2.解释Local自动释放内资源

Local 句柄是一种临时的句柄，用于处理一次性的 I/O 操作，比如读取一个文件或者发送一个网络请求。Local 句柄在 I/O 操作完成后会自动关闭，因此不需要手动释放资源。这是因为 Local 句柄是通过 node::MakeCallback() 方法来实现异步 I/O 操作的，该方法会在 I/O 操作完成后自动调用回调函数，并且会自动释放 Local 句柄。因此，你不需要手动释放 Local 句柄，也不需要担心内存泄漏的问题。

3.解释下v8::HandleScope和v8::Context

v8::HandleScope 是 V8 引擎中的一个类，用于管理 JavaScript 对象的生命周期。在 V8 引擎中，所有的 JavaScript 对象都是通过 v8::Handle 类来表示的，而 v8::HandleScope 则是用于管理这些 v8::Handle 对象的生命周期的。具体来说，v8::HandleScope 可以将一组 v8::Handle 对象绑定到一个作用域中，当作用域结束时，v8::HandleScope 会自动释放这些 v8::Handle 对象，从而避免内存泄漏的问题。v8::Context 是 V8 引擎中的一个类，用于表示 JavaScript 的执行上下文。在 V8 引擎中，每个 JavaScript 对象都是在某个执行上下文中创建的，而 v8::Context 则是用于管理这些执行上下文的。具体来说，v8::Context 可以将一组 JavaScript 对象绑定到一个执行上下文中，从而实现 JavaScript 对象的隔离和沙箱。在 Node.js 中，每个 JavaScript 模块都会被包装成一个 v8::Context 对象，从而实现模块之间的隔离和沙箱。

4.这个v8::Handle是Local

v8::Handle 有两种类型：Local 和 Persistent。其中，Local 句柄是一种临时的句柄，用于处理一次性的 I/O 操作，比如读取一个文件或者发送一个网络请求。Local 句柄在 I/O 操作完成后会自动关闭，因此不需要手动释放资源。这是因为 Local 句柄是通过 node::MakeCallback() 方法来实现异步 I/O 操作的，该方法会在 I/O 操作完成后自动调用回调函数，并且会自动释放 Local 句柄。因此，你不需要手动释放 Local 句柄，也不需要担心内存泄漏的问题。而 Persistent 句柄则是一种长期存在的句柄，用于处理需要持续监听的 I/O 操作，比如监听一个网络端口或者一个文件的变化。Persistent 句柄需要手动释放资源，否则会导致内存泄漏。在 Node.js 中，Local 和 Persistent 句柄都是通过 node::ObjectWrap 类来实现的。具体来说，可以通过继承 node::ObjectWrap 类来创建一个自定义的 Local 或 Persistent 句柄类，然后在类的构造函数中调用 Wrap() 方法来将 C++ 对象绑定到 JavaScript 对象上。在 JavaScript 层面上，可以通过 new 关键字来创建一个 Local 或 Persistent 句柄对象，然后调用对象的方法来进行异步 I/O 操作。

5.是在使用Local时必须先创建一个HandleScope吗，不然Local的资源无法自动释放？

是的，如果你在使用 Local 句柄时没有创建 HandleScope，则会导致 Local 句柄无法自动释放，从而导致内存泄漏的问题。因此，在使用 Local 句柄时，你需要先创建一个 HandleScope 对象，然后将 Local 句柄绑定到该对象中，从而实现 Local 句柄的自动释放。具体来说，你可以按照以下步骤来使用 Local 句柄：创建一个 HandleScope 对象。创建一个 Local 句柄对象，并将其绑定到 HandleScope 对象中。在 HandleScope 对象的作用域内使用 Local 句柄对象。当 HandleScope 对象的作用域结束时，Local 句柄对象会自动释放。以下是一个使用 Local 句柄的示例代码：

void MyFunction() {
  v8::Isolate* isolate = v8::Isolate::GetCurrent();
  v8::HandleScope handle_scope(isolate);
  v8::Local<v8::String> str = v8::String::NewFromUtf8(isolate, "Hello, world!");
  printf("%s\n", *v8::String::Utf8Value(str));
}

在上面的代码中，我们首先创建了一个 HandleScope 对象，然后创建了一个 Local 句柄对象 str，并将其绑定到 HandleScope 对象中。在 HandleScope 对象的作用域内，我们使用了 str 对象，并将其转换成了一个 C 字符串，然后将其打印出来。当 HandleScope 对象的作用域结束时，str 对象会自动释放，从而避免了内存泄漏的问题。

6.这里说在HandleScope 对象的作用域内，那么在HandleScope被创建前先创建了一个Local对象，如Local<Context> context,那么这个context对象就不会被自动释放吗？

是的，如果你在使用 Local 句柄时没有创建 HandleScope，则会导致 Local 句柄无法自动释放，从而导致内存泄漏的问题。因此，在使用 Local 句柄时，你需要先创建一个 HandleScope 对象，然后将 Local 句柄绑定到该对象中，从而实现 Local 句柄的自动释放。具体来说，你可以按照以下步骤来使用 Local 句柄：

创建一个 HandleScope 对象。

创建一个 Local 句柄对象，并将其绑定到 HandleScope 对象中。

在 HandleScope 对象的作用域内使用 Local 句柄对象。

当 HandleScope 对象的作用域结束时，Local 句柄对象会自动释放。

void MyFunction() {
  v8::Isolate* isolate = v8::Isolate::GetCurrent();
  v8::HandleScope handle_scope(isolate);
  v8::Local<v8::String> str = v8::String::NewFromUtf8(isolate, "Hello, world!");
  printf("%s\n", *v8::String::Utf8Value(str));
}

7.在上面的代码中，我们首先创建了一个 HandleScope 对象，然后创建了一个 Local 句柄对象 str，并将其绑定到 HandleScope 对象中。在 HandleScope 对象的作用域内，我们使用了 str 对象，并将其转换成了一个 C 字符串，然后将其打印出来。当 HandleScope 对象的作用域结束时，str 对象会自动释放，从而避免了内存泄漏的问题。因此，如果你在创建 Local 对象之前创建了 HandleScope 对象，那么 `Local 继续输出后续内容

在上面的代码中，我们首先创建了一个 HandleScope 对象，然后创建了一个 Local 句柄对象 str，并将其绑定到 HandleScope 对象中。在 HandleScope 对象的作用域内，我们使用了 str 对象，并将其转换成了一个 C 字符串，然后将其打印出来。当 HandleScope 对象的作用域结束时，str 对象会自动释放，从而避免了内存泄漏的问题。因此，如果你在创建 Local 对象之前创建了 HandleScope 对象，那么 Local 对象会自动释放，从而避免了内存泄漏的问题。如果你没有创建 HandleScope 对象，那么 Local 对象就无法自动释放，从而导致内存泄漏的问题。

8.这是说的内存泄露都是js层面的吧？

是的，这里说的内存泄漏主要是指 JavaScript 层面的内存泄漏。在 Node.js 中，JavaScript 代码是运行在 V8 引擎中的，而 V8 引擎是一个独立的进程，它与 Node.js 进程是通过 IPC 通信的。因此，在 JavaScript 层面上发生的内存泄漏，主要是指 V8 引擎中的内存泄漏。当然，如果你在编写 C++ 扩展时没有正确地管理内存，也可能会导致 C++ 层面的内存泄漏。

9.我没看看到这里用户代码手动将Local绑定到HandleScope上，能说明下内部实现机制吗

Local 对象的实现机制是基于引用计数的。每个 Local 对象都包含一个指向实际对象的指针，同时还包含一个指向引用计数的指针。引用计数的初始值为 1，每当一个 Local 对象被复制或者传递给其他函数时，引用计数都会加 1。当引用计数为 0 时，Local 对象就会被自动释放。

HandleScope 对象的实现机制是基于栈的。每当创建一个 HandleScope 对象时，就会在当前线程的栈上分配一段内存，用于存储 v8::Handle 对象。当 HandleScope 对象的作用域结束时，这些 v8::Handle 对象就会被自动释放。

在使用 Local 对象时，你需要将其绑定到 HandleScope 对象中，从而实现 Local 对象的自动释放。具体来说，当你将一个 Local 对象绑定到 HandleScope 对象中时，HandleScope 对象会将其引用计数加 1，从而避免了 Local 对象被自动释放的问题。当 HandleScope 对象的作用域结束时，HandleScope 对象会将其引用计数减 1，从而实现 Local 对象的自动释放。

10.可以这么理解吗，就是HandleScope的作用就是将绑定的Local对象的引用计数加1，在HandleScope作用域结束时，将这些Local对象的引用计数减去1？

是的，你理解得很对。HandleScope 的作用就是将绑定的 Local 对象的引用计数加 1，在 HandleScope 作用域结束时，将这些 Local 对象的引用计数减去 1。这样做的好处是，可以避免 Local 对象被自动释放，从而避免内存泄漏的问题。

11.那如果在一个函数中创建了Local对象但没有创建HandleScope,那在函数执行到一半时遇到了v8的垃圾回收，这些Local对象会直接被回收掉，在后半部分的函数逻辑中拿不到这个句柄实际指向的对象了吗

是的，如果在一个函数中创建了 Local 对象但没有创建 HandleScope，那么在函数执行到一半时遇到了 V8 的垃圾回收，这些 Local 对象会直接被回收掉，从而导致后半部分的函数逻辑中无法访问这些 Local 对象实际指向的对象。因此，在编写 C++ 扩展时，一定要注意正确地使用 HandleScope 对象，以避免出现内存泄漏和访问非法内存的问题。

12.这是一个概率问题吗，不一定遇到但存在隐患？

是的，这是一个概率问题。在一个函数中创建 Local 对象但没有创建 HandleScope，并不一定会导致内存泄漏或者访问非法内存的问题。这是因为 V8 引擎的垃圾回收机制是基于分代的，而且是异步的。也就是说，当一个 Local 对象被创建时，它并不会立即被回收，而是会被放到 V8 引擎的新生代中。只有当新生代中的内存占用达到一定阈值时，V8 引擎才会触发垃圾回收。因此，如果在一个函数中创建了 Local 对象但没有创建 HandleScope，并且这些 Local 对象被放到了新生代中，那么在函数执行到一半时遇到了 V8 的垃圾回收，这些 Local 对象就有可能被回收掉，从而导致内存泄漏或者访问非法内存的问题。虽然这种情况的发生概率比较低，但是仍然存在隐患。因此，在编写 C++ 扩展时，一定要注意正确地使用 HandleScope 对象，以避免出现内存泄漏和访问非法内存的问题。

13.Context对象与js中的概念是如何对应的呢，是类似于一个函数作用域、全局作用域这样的概念吗？

Context 对象是 V8 引擎中的一个重要概念，它代表了一个 JavaScript 执行上下文。在 V8 引擎中，每个 JavaScript 函数都有自己的执行上下文，用于存储函数的局部变量、参数、this 指针等信息。Context 对象就是用来管理这些执行上下文的，它可以看作是一个 JavaScript 的全局对象，用于存储全局变量、函数等信息。在 V8 引擎中，每个线程都有自己的 Context 对象，用于存储该线程中所有 JavaScript 函数的执行上下文。当一个 JavaScript 函数被调用时，V8 引擎会将该函数的执行上下文压入当前线程的 Context 对象中，当函数执行完毕后，V8 引擎会将该函数的执行上下文从 Context 对象中弹出，从而实现 JavaScript 函数的嵌套调用。

因此，Context 对象与 JavaScript 中的函数作用域、全局作用域等概念是有一定的相似之处的。它们都是用来管理 JavaScript 函数的执行上下文的，只不过 Context 对象是 V8 引擎中的一个特殊对象，用于管理所有 JavaScript 函数的执行上下文。

14.每一个Nodejs进程都只创建一个Context吗

每个 Node.js 进程都有一个默认的 Context 对象，称为全局 Context 对象。在 Node.js 中，全局 Context 对象是由 global 对象表示的。当 Node.js 启动时，它会创建一个默认的全局 Context 对象，并将其绑定到 global 对象上。在 Node.js 中，所有的 JavaScript 代码都是在全局 Context 对象中执行的，因此可以说每个 Node.js 进程都只创建一个全局 Context 对象。但是，Node.js 中也可以创建自定义的 Context 对象，用于实现一些特殊的功能。如果你需要创建自定义的 Context 对象，可以使用 vm 模块提供的 API。

15.MaybeLocal和Local的区别是什么呀

MaybeLocal 和 Local 都是 V8 引擎中的句柄类型，用于管理 JavaScript 对象的生命周期。它们的主要区别在于，MaybeLocal 句柄可以为空，而 Local 句柄不可以为空。

具体来说，MaybeLocal 句柄是一个模板类，它的模板参数是一个 Local 句柄类型。MaybeLocal 句柄可以表示一个可能为空的 Local 句柄，因此在使用 MaybeLocal 句柄时，需要先判断其是否为空，然后再将其转换成 Local 句柄。如果 MaybeLocal 句柄为空，那么将其转换成 Local 句柄会导致程序崩溃。

以下是一个使用 MaybeLocal 句柄的示例代码：

void MyFunction() {
  v8::Isolate* isolate = v8::Isolate::GetCurrent();
  v8::HandleScope handle_scope(isolate);
  v8::Local<v8::String> str = v8::String::NewFromUtf8(isolate, "Hello, world!");
  v8::MaybeLocal<v8::String> maybe_str = v8::String::NewFromUtf8(isolate, "Hello, world!");
  if (!maybe_str.IsEmpty()) {
    v8::Local<v8::String> str2 = maybe_str.ToLocalChecked();
    printf("%s\n", *v8::String::Utf8Value(str2));
  }
}

在上面的代码中，我们首先创建了一个 HandleScope 对象，然后创建了一个 Local 句柄对象 str 和一个 MaybeLocal 句柄对象 maybe_str。在使用 maybe_str 对象时，我们首先判断其是否为空，然后再将其转换成 Local 句柄对象 str2。如果 maybe_str 对象为空，那么 str2 对象也会为空，从而避免了程序崩溃的问题。

16.创建Persistent句柄需要用户手动销毁吗？能给一段实例代码吗

创建 Persistent 句柄需要用户手动销毁，否则会导致内存泄漏。在 C++ 扩展中，可以通过以下方式创建 Persistent 句柄：

void MyFunction() {
  v8::Isolate* isolate = v8::Isolate::GetCurrent();
  v8::HandleScope handle_scope(isolate);
  v8::Local<v8::String> str = v8::String::NewFromUtf8(isolate, "Hello, world!");
  v8::Persistent<v8::String> persistent_str(isolate, str);
  // ...
  persistent_str.Reset();
}

在上面的代码中，我们首先创建了一个 HandleScope 对象，然后创建了一个 Local 句柄对象 str。接着，我们使用 isolate 和 str 对象创建了一个 Persistent 句柄对象 persistent_str。在使用 persistent_str 对象时，我们可以像使用 Local 句柄对象一样进行操作。在 persistent_str 对象不再需要时，我们需要手动调用 Reset() 方法来销毁该对象。在调用 Reset() 方法后，persistent_str 对象就不再有效，其所引用的 JavaScript 对象也会被垃圾回收器回收。

17.可以理解为调用永久句柄的Reset函数，如果形参是空，那么就将这个永久句柄至无效了，等待v8的垃圾回收吗

Persistent 句柄的 Reset() 方法用于销毁该句柄对象。如果 Reset() 方法的参数为空，那么该句柄对象就会变成无效的，等待 V8 引擎的垃圾回收器回收。如果 Reset() 方法的参数不为空，那么该句柄对象就会引用新的 JavaScript 对象。在 C++ 扩展中，可以通过以下方式调用 Reset() 方法：

void MyFunction() {
  v8::Isolate* isolate = v8::Isolate::GetCurrent();
  v8::HandleScope handle_scope(isolate);
  v8::Local<v8::String> str = v8::String::NewFromUtf8(isolate, "Hello, world!");
  v8::Persistent<v8::String> persistent_str(isolate, str);
  // ...
  persistent_str.Reset();
}

在上面的代码中，我们首先创建了一个 HandleScope 对象，然后创建了一个 Local 句柄对象 str。接着，我们使用 isolate 和 str 对象创建了一个 Persistent 句柄对象 persistent_str。在使用 persistent_str 对象时，我们可以像使用 Local 句柄对象一样进行操作。在 persistent_str 对象不再需要时，我们需要手动调用 Reset() 方法来销毁该对象。在调用 Reset() 方法后，persistent_str 对象就不再有效，其所引用的 JavaScript 对象也会被垃圾回收器回收。如果 Reset() 方法的参数为空，那么 persistent_str 对象就会变成无效的，等待 V8 引擎的垃圾回收器回收。

Tags 标签

node.js

扩展阅读