Question

将ref-struct实例嵌套到另一个实例中，则在手动进行垃圾回收时，嵌套对象的一个属性会损坏。

请参见以下最小代码重现：https://github.com/hunterlester/minimum-ref-struct-corruption

在日志输出的第三行上，通知name的值未损坏：

Running garbage collection...
authGranted object afte gc:  { name: '�_n9a\u0002', 'ref.buffer': <Buffer@0x00000261396F3910 18 86 6c 39 61 02 00 00> }
Unnested access container entry after gc:  { name: 'apps/net.maidsafe.examples.mailtutorial', 'ref.buffer': <Buffer@0x00000261396F3B10 60 68 6e 39 61 02 00 00> }
Globally assigned values after gc:  apps/net.maidsafe.examples.mailtutorial  _publicNames

Answer 1

虽然ref，ref-struct和ref-array很强大，但是很脆弱，但是它们的组合却表现得很模糊。

样本有两个细微差别：

两次调用makeAccessContainerEntry会覆盖您的全局缓存-在CStrings调用期间global.x0 cached（global.x1和makeAuthGrantedFfiStruct）将被第二个直接makeAccessContainerEntry call覆盖。
似乎您也应该缓存每个ContainerInfoArray。

此代码应该可以正常工作：

const ArrayType = require('ref-array');
const ref = require('ref');
const Struct = require('ref-struct');
const CString = ref.types.CString;

const ContainerInfo = Struct({
  name: CString
});

const ContainerInfoArray = new ArrayType(ContainerInfo);

const AccessContainerEntry = Struct({
  containers: ref.refType(ContainerInfo)
});

const AuthGranted = Struct({
  access_container_entry: AccessContainerEntry
});

const accessContainerEntry = [
  {
    "name": "apps/net.maidsafe.examples.mailtutorial",
  },
  {
    "name": "_publicNames",
  }
];

const makeAccessContainerEntry = (accessContainerEntry) => {
  const accessContainerEntryCache = {
    containerInfoArrayCache: null,
    containerInfoCaches: [],
  };
  accessContainerEntryCache.containerInfoArrayCache = new ContainerInfoArray(accessContainerEntry.map((entry, index) => {
    const name = ref.allocCString(entry.name);
    accessContainerEntryCache.containerInfoCaches.push(name);
    return new ContainerInfo({ name });
  }));
  return {
    accessContainerEntry: new AccessContainerEntry({
      containers: accessContainerEntryCache.containerInfoArrayCache.buffer,
    }),
    accessContainerEntryCache,
  };
};

const makeAuthGrantedFfiStruct = () => {
  const ace = makeAccessContainerEntry(accessContainerEntry);
  return {
    authGranted: new AuthGranted({
      access_container_entry: ace.accessContainerEntry,
    }),
    authGrantedCache: ace.accessContainerEntryCache,
  };
}

const authGranted = makeAuthGrantedFfiStruct();
const unNestedContainerEntry = makeAccessContainerEntry(accessContainerEntry);

if(global.gc) {
  console.log('Running garbage collection...');
  global.gc();
}

console.log('authGranted object afte gc: ', authGranted.authGranted.access_container_entry.containers.deref());
console.log('Unnested access container entry after gc: ', unNestedContainerEntry.accessContainerEntry.containers.deref());

如您所见，我在makeAccessContainerEntry输出中添加了缓存，只要您需要从垃圾回收中保存数据，就应该将其保留在某个地方。

修改：背景知识

JS实现了高级Memory Management，其中对象由引用引用，并且只要不再有对特定对象的引用，就会释放内存。

在C语言中没有引用和GC，但是有一些指针，它们只是简单的内存地址，指向特定结构或内存块所在的位置。

ref使用以下技术将两者绑定：C指针是一个Buffer，用于存储内存中实际数据所在的内存地址。实际数据通常也表示为缓冲区。

ref-struct是ref的附加组件，它实现了将底层内存块（缓冲区）解释为结构的功能-用户定义类型以及它们在内存中的位置，ref-struct试图读取内存块的相应部分并获取值。

ref-array是ref的附加组件，它实现了将底层内存块（缓冲区）解释为数组的功能-用户定义类型以及它们在内存中的位置，ref-array试图读取内存块的相应部分并获取数组项。

这样，如果您为某个东西分配一个Buffer，然后获得对其的ref引用（一个仅保存原始Buffer的内存地址的新Buffer），并且丢失了对原始Buffer的JS引用，那么原始的Buffer可能会这样被GC释放：

function allocateData() {
  const someData = Buffer.from('sometext');
  return ref.ref(data);
}

const refReference = allocateData();
// There are no more direct JS references to someData - they are all left in the scope of allocateData() function.

console.log(refReference.deref());
global.gc(); // As long as there are no more JS references to someData, GC will release it and use its memory for something else.
console.log(refReference.deref());

请不要着急测试此代码-console.log(refReference.deref());会打印相同的输出，因为ref在data中保留了对引用的refReference的隐藏引用。

ref-struct和ref-array意识到这种情况，通常也正确地保留对引用数据的隐藏引用。但是ref-struct和ref-array的组合显示出一个错误或潜在的不兼容性，并且隐藏的引用有时会丢失。一种解决方法是自己缓存参考-这是我建议使用的方法。

垃圾回收时，NodeJS引用结构中的内容已损坏

1 个答案: