C++ 调用处理程序数据的垃圾收集

我试图向函数调用处理程序提供数据，但无法正确地进行垃圾收集

如果我注释掉包含“

tpl->SetCallHandler（callFn，external）；

”的行，将调用ObjWeakCallback。尽管如此，函数从未被收集（至少FnWeakCallback从未被调用，无论发生什么）

请注意，静态数据不是一个选项，因为这需要为每个进程的多个隔离做好准备。

隔离->设置数据

也不是一个选项。我完全错过了什么吗？ 在

v8:：Function

中存储数据的正确方法是什么

---

编辑：让我重新表述这个问题，以便更好地描述我的意图

我想创建一个函数模板（因为我需要在JS端将其用作构造函数）。 我需要某种方法将void*发送到它的调用处理程序，但这些数据必须是可垃圾回收的

到目前为止，我一直在尝试的一些注意事项：

• 使用

  Function:：New（隔离，callHandler，External:：New（隔离，数据））

  可以工作，但不提供JS端构造函数功能（无法为创建的对象设置InternalFieldCount）

• FunctionTemplate:：New（隔离，callHandler，External:：New（隔离，数据））

  提供了将数据传递给调用处理程序的功能，但从不进行垃圾收集（下面的工作示例）

• 我尝试使用一个普通函数并返回一个新创建的

  对象

  ，但是下面的假设

  new Fn（）instanceof Fn

  失败了

---

#包括
#包括
//设置为静态，只是为了简化示例并防止崩溃
//持久性通常与所需数据一起包装在“指挥棒”中
v8:：持久性p_obj；
v8:：持久性p_fn；
void FnWeakCallback（const v8:：WeakCallbackData和data）{
int*number=data.GetParameter（）；
std：：cout现在我作弊了，并且看了

所以答案必须是：在第一次收集之后，你不会看到任何东西。
我认为，当你删除一些与你的问题毫无共同之处的代码时，会有更多的人考虑回答你的问题。另外，好主意是在代码中标记你谈论的行。在垃圾收集的“RequestGarbageCollectio”点上NFoTest'是JS垃圾收集还是应该在“测试”中分配的所有内存在C++程序中释放？@ Surt：这是一个JS端GC。
#include <v8.h>
#include <iostream>

// made static, just to simplify the example and prevent crashes
// the persistents would normally be wrapped inside a "baton" together with required data
v8::Persistent<v8::Value> p_obj;
v8::Persistent<v8::Value> p_fn;

void FnWeakCallback(const v8::WeakCallbackData<v8::Value, int>& data) {
    int* number = data.GetParameter();
    std::cout << "GC fn " << number << '\n';
    delete number;
    p_fn.Reset();
}

void ObjWeakCallback(const v8::WeakCallbackData<v8::Value, int>& data) {
    int* number = data.GetParameter();
    std::cout << "GC obj " << number << '\n';
    delete number;
    p_obj.Reset();
}

void callFn(const v8::FunctionCallbackInfo<v8::Value>& info) {
    std::cout << "called\n";
}

void test(v8::Isolate* isolate) {
    v8::HandleScope scope(isolate);

    auto external = v8::External::New(isolate, new int{ 1 });
    p_obj.Reset(isolate, external);
    p_obj.SetWeak(new int{ 1 }, ObjWeakCallback);

    auto tpl = v8::FunctionTemplate::New(isolate);
    tpl->SetCallHandler(callFn, external); // <======
    tpl->InstanceTemplate()->SetInternalFieldCount(1);
    auto fn = tpl->GetFunction();

    p_fn.Reset(isolate, fn);
    p_fn.SetWeak(new int{ 2 }, FnWeakCallback);
}

int main() {
    v8::V8::SetFlagsFromString("--expose-gc", 11);

    auto isolate = v8::Isolate::GetCurrent();
    v8::HandleScope handle_scope(isolate);
    auto context = v8::Context::New(isolate);
    context->Enter();

    test(isolate);

    isolate->RequestGarbageCollectionForTesting(v8::Isolate::kFullGarbageCollection);
    context->Exit();

    return 0;
}

void GCController::CollectAll(const gin::Arguments& args) {
// In order to collect a DOM wrapper, two GC cycles are needed.
// In the first GC cycle, a weak callback of the DOM wrapper is called back
// and the weak callback disposes a persistent handle to the DOM wrapper.
// In the second GC cycle, the DOM wrapper is reclaimed.
// Given that two GC cycles are needed to collect one DOM wrapper,
// more than two GC cycles are needed to collect all DOM wrappers
// that are chained. Seven GC cycles look enough in most tests.