1

我有 2 个关于 boehm-gc 的问题。

  1. 当 GC 收集垃圾对象时，尽管对象具有析构函数，但 GC 释放内存而不调用析构函数。我发现 GC 调用“finilizer”，但我不知道如何注册它......我该怎么办？

  2. 当 GC 收集垃圾时，GC 似乎没有调用 free() （或其他内存释放函数）。看起来GC并没有释放垃圾，而是将其放入GC的内存池中，并在下次分配时使用池。GC空闲时释放内存池？如果没有，我可以对 GC 说“请释放内存池”吗？

PS。我找不到 boehm-gc 参考资料。你能告诉我参考资料在哪里吗？

4

1 回答 1

3

如果您需要比gc.h头文件中提供的更多参考，那么您可能应该在继续之前阅读垃圾收集器。

你的问题，gc.h标题有你需要的：

typedef void (*GC_finalization_proc)
  GC_PROTO((GC_PTR obj, GC_PTR client_data));

GC_API void GC_register_finalizer
    GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
      GC_finalization_proc *ofn, GC_PTR *ocd));
GC_API void GC_debug_register_finalizer
    GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
      GC_finalization_proc *ofn, GC_PTR *ocd));
/* When obj is no longer accessible, invoke     */
/* (*fn)(obj, cd).  If a and b are inaccessible, and    */
/* a points to b (after disappearing links have been    */
/* made to disappear), then only a will be      */
/* finalized.  (If this does not create any new     */
/* pointers to b, then b will be finalized after the    */
/* next collection.)  Any finalizable object that   */
/* is reachable from itself by following one or more    */
/* pointers will not be finalized (or collected).   */
/* Thus cycles involving finalizable objects should */
/* be avoided, or broken by disappearing links.     */
/* All but the last finalizer registered for an object  */
/* is ignored.                      */
/* Finalization may be removed by passing 0 as fn.  */
/* Finalizers are implicitly unregistered just before   */
/* they are invoked.                    */
/* The old finalizer and client data are stored in  */
/* *ofn and *ocd.                   */ 
/* Fn is never invoked on an accessible object,     */
/* provided hidden pointers are converted to real   */
/* pointers only if the allocation lock is held, and    */
/* such conversions are not performed by finalization   */
/* routines.                        */
/* If GC_register_finalizer is aborted as a result of   */
/* a signal, the object may be left with no     */
/* finalization, even if neither the old nor new    */
/* finalizer were NULL.                 */
/* Obj should be the nonNULL starting address of an     */
/* object allocated by GC_malloc or friends.        */
/* Note that any garbage collectable object referenced  */
/* by cd will be considered accessible until the    */
/* finalizer is invoked.                */

所以你定义了一个回调：

typedef <any type at all you want passed to the callback
         as data for its own use> MY_ENVIRONMENT;

void my_callback(GC_PTR void_obj, GC_PTR void_environment) {
  MY_ENVIRONMENT *env = (MY_ENVIRONMENT)void_environment;
  MY_OBJECT *obj = (MY_OBJECT*)void_obj;

  // Do finalization here.
}

创建它的环境（如果有的话；否则只传递 NULL）：

MY_ENVIRONMENT *my_env = new MY_ENVIRONMENT;
// Initialize if necessary.

然后在一个新分配的对象上注册它：

MY_
MY_ENVIRONMENT old_env;
GC_finalization_proc old_proc;
GC_register_finalizer(new_obj, my_callback, my_env, &old_env, &old_proc);

现在my_callback将在收集此特定对象时使用您的环境记录调用。

至于你的问题2，你没有抓住重点。Boehm GC替换malloc/new 和 free 并管理自己的内存领域。它通常自行决定何时进行收集。这通常是在大部分竞技场已经用完的时候。垃圾收集识别空闲块，因此有资格重新分配。正如API 说明清楚地表明，您可以强制收集和强制释放对象，但这些通常不是必需的。

于 2013-12-22T07:33:48.523 回答