Яким чином закриття JavaScript збирає сміття

Я зареєстрував таку помилку Chrome , що призвело до багатьох серйозних і неочевидних витоків пам'яті в моєму коді:

(У цих результатах використовується профайлер пам'яті Chrome Dev Tools , який запускає GC, а потім робить знімок всього, що не збирається зібрано.)

У наведеному нижче коді someClassекземпляр збирається сміттям (добре):

var someClass = function() {};

function f() {
  var some = new someClass();
  return function() {};
}

window.f_ = f();

Але в цьому випадку сміття не буде зібрано (погано):

var someClass = function() {};

function f() {
  var some = new someClass();
  function unreachable() { some; }
  return function() {};
}

window.f_ = f();

І відповідний знімок екрана:

Схоже, що закриття (в даному випадку function() {}) зберігає всі об'єкти "живими", якщо на об'єкт посилається будь-яке інше закриття в тому ж контексті, незалежно від того, чи є це закриття навіть доступним.

Моє запитання - про збирання сміття в інших браузерах (IE 9+ та Firefox). Я добре знайомий з інструментами webkit, такими як профільний купон JavaScript, але мало знаю інших інструментів браузера, тому мені не вдалося перевірити це.

У якому з цих трьох випадків сміття IE9 + та Firefox збиратиме someClass екземпляр?

Наскільки я можу сказати, це не помилка, а очікувана поведінка.

На сторінці управління пам’яттю Mozilla : «З 2012 року всі сучасні браузери доставляють сміттєзбірник». "Обмеження: об'єкти потрібно робити явно недоступними " .

У ваших прикладах, де вона не вдається some, все ще можна дістатись до закриття. Я спробував два способи зробити це недосяжним, і обидва працюють. Або ви встановите, some=nullколи він вам більше не потрібен, або ви встановите, window.f_ = null;і він пропаде.

Оновлення

Я спробував це в Chrome 30, FF25, Opera 12 та IE10 в Windows.

Стандарт нічого не знаю про збірку сміття не говорить, але дає деякі підказки про те, що має статися.

• Розділ 13 Визначення функції, крок 4: "Нехай закриття є результатом створення нового об'єкта Функції, як зазначено в 13.2"
• Розділ 13.2 "Лексичне середовище, визначене сферою дії" (сфера дії = закриття)
• Розділ 10.2 Лексичні середовища:

"Зовнішня посилання на (внутрішнє) лексичне середовище - це посилання на лексичне середовище, що логічно оточує внутрішнє лексичне середовище.

Зовнішнє лексичне середовище, звичайно, може мати своє зовнішнє лексичне середовище. Лексичне середовище може служити зовнішнім середовищем для кількох внутрішніх лексичних середовищ. Наприклад, якщо декларація функції містить дві вкладені декларації функції, то лексичне середовище кожної з вкладених функцій матиме як їх зовнішнє лексичне середовище лексичне середовище поточного виконання оточуючої функції. "

Отже, функція матиме доступ до оточення батьків.

Отже, someповинні бути доступні при закритті функції, що повертається.

Тоді чому він не завжди доступний?

Здається, що Chrome і FF досить розумні, щоб усунути змінну в деяких випадках, але і в Opera, і в IE someзмінна доступна у закритті (Примітка: для перегляду цього встановлення точки перерви return nullта перевірки налагоджувача).

ГК можна вдосконалити, щоб виявити some, використовується він чи ні у функціях, але це буде складним.

Поганий приклад:

var someClass = function() {};

function f() {
  var some = new someClass();
  return function(code) {
    console.log(eval(code));
  };
}

window.f_ = f();
window.f_('some');

У прикладі вище GC не може знати, застосовується чи ні змінна (тестується код і працює в Chrome30, FF25, Opera 12 та IE10).

Пам'ять вивільняється, якщо посилання на об'єкт порушено шляхом призначення іншого значення window.f_.

На мою думку, це не помилка.

Я перевірив це в IE9 + і Firefox.

function f() {
  var some = [];
  while(some.length < 1e6) {
    some.push(some.length);
  }
  function g() { some; } //removing this fixes a massive memory leak
  return function() {};   //or removing this
}

var a = [];
var interval = setInterval(function() {
  var len = a.push(f());
  if(len >= 500) {
    clearInterval(interval);
  }
}, 10);

Живий сайт тут .

Я сподівався закінчитись масивом 500 function() {}-х, використовуючи мінімальну пам'ять.

На жаль, це було не так. Кожна порожня функція містить у собі (назавжди недосяжний, але не GC'ed) масив з мільйона чисел.

З часом Chrome зупиняється і відмирає, Firefox закінчує все після використання майже 4 Гб оперативної пам’яті, а IE росте асимптотично повільніше, поки не з’явиться «Поза пам’яттю».

Видалення будь-якого з коментованих рядків виправляє все.

Схоже, що всі три цих браузери (Chrome, Firefox та IE) зберігають записи про навколишнє середовище за контекстом, а не за закриттям. Борис гіпотезує, що причина цього рішення - це ефективність, і це здається вірогідним, хоча я не впевнений, наскільки виконавцем його можна назвати у світлі вищезазначеного експерименту.

Якщо вам потрібне посилання про закриття some(дано, я тут його не використовував, але уявіть, що я зробив), якщо замість цього

function g() { some; }

я використовую

var g = (function(some) { return function() { some; }; )(some);

це виправить проблеми з пам'яттю, перемістивши закриття в інший контекст, ніж моя інша функція.

Це зробить моє життя набагато втомливішим.

PS З цікавості, я спробував це на Java (використовуючи його здатність визначати класи всередині функцій). GC працює так, як я спочатку сподівався на Javascript.

Евристика відрізняється, але загальним способом реалізації подібних речей є створення запису про оточення для кожного дзвінка f()у вашому випадку, і зберігати лише місцеві жителі f, які фактично закриті ( деяким закриттям) у цьому записі оточення. Тоді будь-яке закриття, створене під час виклику, щоб fзберегти живий запис середовища. Я вважаю, що саме так Firefox реалізує закриття, принаймні.

Це має переваги швидкого доступу до змінних, що закриваються, та простоти реалізації. Він має недолік спостережуваного ефекту, коли короткочасне закриття над деякою змінною призводить до того, що він зберігається в живих завдяки довготривалим закриттям.

Можна спробувати створити кілька записів навколишнього середовища для різних закриттів, залежно від того, чим вони насправді закриваються, але це може дуже швидко ускладнитися і може спричинити власні проблеми та пам'ять ...

1. Підтримуйте стан між викликами функцій Скажімо, у вас є функція add (), і ви хочете, щоб вона додала всі значення, передані їй у декілька викликів, і повертала суму.

як додати (5); // повертає 5

додати (20); // повертає 25 (5 + 20)

додати (3); // повертає 28 (25 + 3)

два способи зробити це спочатку - це нормально визначити глобальну змінну Звичайно, ви можете використовувати глобальну змінну, щоб утримувати загальну величину. Але майте на увазі, що цей чувак з'їсть вас живими, якщо ви (аб) будете користуватися глобальними.

Тепер останній спосіб використання закриття з out визначити глобальну змінну

(function(){

  var addFn = function addFn(){

    var total = 0;
    return function(val){
      total += val;
      return total;
    }

  };

  var add = addFn();

  console.log(add(5));
  console.log(add(20));
  console.log(add(3));
  
}());