CJS 中的记忆增长

我使用heapgraph工具分析了原始程序。删除 500 个按钮后，它们在堆转储中可见，但标记为“无法访问”。因此它们没有泄漏，它们只会在下一次垃圾收集中被删除。

问题似乎是垃圾收集器未被触发。这可能是已知问题https://gitlab.gnome.org/GNOME/gjs/-/issues/52。目前，您可以通过imports.system.gc()在销毁按钮后添加并清空引用来手动触发垃圾收集。如果我将该行添加到原始脚本中，即使以两倍的速度创建按钮并运行 10 分钟，内存使用量也不会超过 19 MB。

好的，经过几个小时的测试，我明白了。
我必须在 destroy 信号处理程序中释放 GJS 持有的引用，所有其他尝试都会导致内存泄漏。
我不知道为什么，但在使用 Gtk.widget.destroy() 后简单地将 GJS 中的引用设置为 null 不起作用，如果您尝试先从父级中删除元素，然后将其引用设置为 null 并让 GJS 销毁它，也会导致内存泄漏。

这有效：

#!/usr/bin/cjs
"use strict";
import Gtk from 'gi://Gtk?version=3.0';
 
Gtk.init (null);

const window=  new Gtk.Window ();
let buttons=[], button, box=new Gtk.Box ({ orientation:1}), remove=true;

function finalize_destroy (button)
    {
    buttons[button.index]=null;
    }

function construct_buttons ()
   {
   for (let i=0;i<500;i++)
      {
      button=new Gtk.Button ({label:"hello"});
      box.add (button);
      button.index=i;
      button.connect ("destroy", finalize_destroy)
      buttons.push (button);
      }
   }
   
setInterval (function ()   
   {
   if (remove)
      {
      for (let i=0;i<500;i++) buttons[i].destroy ();
      buttons=[];
      }
   else
      {
      construct_buttons ();
      window.show_all ();
      }
   remove=!remove;
   }, 2000);

construct_buttons ();
      
window.add(box);
window.set_title ("Test");
window.connect ('destroy', () => { Gtk.main_quit (); });
window.set_size_request (740, 600);
window.show_all ();

Gtk.main ();

因此，如果我构建自己的小部件（由许多 Gtk 小部件组成），我会将所有小部件收集到“小部件”命名空间容器对象中。
构建后，我将每个小部件的处理程序连接到销毁信号，并在销毁处理程序中释放引用。
我不知道这是否是正确的方法，但它有效。
一个更复杂的例子：

#!/usr/bin/cjs
"use strict";
import Gtk from 'gi://Gtk?version=3.0';
 
Gtk.init (null);

const window=  new Gtk.Window ();
let top_box=new Gtk.Box ({ orientation:1}), own_widgets= [], remove=true;

//-- constructor own widgets: which is a collection of structured gtk widgets
function OwnWidget ()
   {
   var widgets=new Object ();
   
   //-- collecting all widgets i construct in container namespace widgets
   widgets.eventbox_for_hbox= new Gtk.EventBox ();                                                           
    widgets.eventbox_for_vbox= new Gtk.EventBox ({halign:1,valign:1});                                          
    widgets.hbox=              new Gtk.Box ({ spacing: 2});
    widgets.vbox=              new Gtk.Box ({ orientation:1, spacing: 2});
    widgets.button_A=          new Gtk.Button ({ label:"Button_A", halign:3, valign:3 }),         
    widgets.button_B=          new Gtk.Button ({ label:"Button_B", halign:3, valign:3 }), 
    widgets.button_C=          new Gtk.Button ({ label:"Button_C", halign:3, valign:3 }), 
   
   //-- some structure: eventbox_for_vbox (top container) -> vbox -> eventbox_for_hbox -> hbox -> buttons                                       
        widgets.hbox.add(widgets.button_A);
        widgets.hbox.add(widgets.button_B);
        widgets.hbox.add(widgets.button_C);
        widgets.eventbox_for_hbox.add (widgets.hbox);
    widgets.vbox.add (widgets.eventbox_for_hbox);
    widgets.eventbox_for_vbox.add (widgets.vbox);
    
    /* connecting destroy handler for every widget -> OwnWidget.prototype.destroy.finalize_destroy is the template function
       and adding a property to every widget called OWNWIDGET_propertyID, which is the widgets property name in the "widgets" object.
       This is needed in finalie_destroy see below. */
    for (let propertyID in widgets)
       {
       widgets[propertyID].connect ("destroy", OwnWidget.prototype.destroy.finalize_destroy.bind (this));
       widgets[propertyID].OWNWIDGET_propertyID=propertyID;
       }
       
    this.widgets=widgets;
    this.top_container=widgets.eventbox_for_vbox;
   }

//-- destroys your own widget
OwnWidget.prototype.destroy=function ()
   {
   this.top_container.destroy ();
   this.top_container=null;
   }

//-- called on signal destroy, releaving the references of GJS in instance.widgets object
OwnWidget.prototype.destroy.finalize_destroy=function destroy (widget)
   {
   this.widgets[widget.OWNWIDGET_propertyID]=null;
   }
   
//-- construct 100 own widgets with the above structure
function construct ()
   {
   let own_widget;
 
   for (let i=0;i<250;i++)
      {
      own_widget=new OwnWidget ();
      top_box.add (own_widget.widgets.eventbox_for_vbox);
      own_widgets[i]=own_widget;
      }
   window.show_all();
   }

//-- removes the 100 own widgets from the top-box and destroys it
function remove_and_destroy ()
   {
   for (let i=0;i<250;i++) 
      {
      own_widgets[i].destroy ();
      /* to be sure, that all is freed, i also set the array reference on the own widget instance null,
         but this will be overwritten by the next construct () call, so i think its not necessary. */
      own_widgets[i]=null;
      }
   }
 
setInterval (function ()   
   {
   if (remove) remove_and_destroy ();
   else construct ();

   remove=!remove;
   }, 3000);

construct ();
window.add(top_box);
window.set_title ("Test");
window.connect ('destroy', () => { Gtk.main_quit (); });
window.set_size_request (740, 600);
window.show_all ();

Gtk.main ();