Какие поколения есть в куче?

Поколения в управляемой куче .NET

В управляемой куче (managed heap) .NET используется алгоритм сборки мусора (Garbage Collection, GC), основанный на поколениях (generations). Этот подход оптимизирует производительность, основываясь на эмпирическом наблюдении: большинство объектов живут очень недолго, в то время как выжившие объекты, как правило, имеют длительное время жизни.

Три основных поколения

Управляемая куча разделена на три поколения:

1. Generation 0 (Gen 0)

    *   **Назначение**: Здесь размещаются **вновь созданные объекты**.
    *   **Размер**: Самое маленькое поколение. Размер динамически настраивается CLR (Common Language Runtime), но обычно составляет несколько мегабайт.
    *   **Особенность**: Сборка мусора в Gen 0 происходит **наиболее часто** и является самой быстрой, так проверяется только небольшая область памяти. Практически все неиспользуемые объекты удаляются здесь.

1. Generation 1 (Gen 1)

    *   **Назначение**: **Буферное поколение**. Сюда попадают объекты, которые пережили сборку мусора в Gen 0.
    *   **Размер**: Имеет промежуточный размер между Gen 0 и Gen 2.
    *   **Особенность**: Сборка мусора здесь происходит реже, чем в Gen 0, но чаще, чем в Gen 2. Она служит своеобразным фильтром, отделяя кратковременные объекты от долгоживущих. Объекты, пережившие сборку в Gen 1, перемещаются в Gen 2.

1. Generation 2 (Gen 2)

    *   **Назначение**: Здесь хранятся **долгоживущие объекты**, которые пережили несколько сборок мусора.
    *   **Размер**: Самое большое поколение, может занимать гигабайты памяти.
    *   **Особенность**: Полная сборка мусора (full GC) в Gen 2 — это наиболее **ресурсоемкая операция**, которая может приводить к заметным паузам в работе приложения.

Особое поколение: Large Object Heap (LOH)

Помимо трех основных поколений, существует куча больших объектов (Large Object Heap, LOH).

• Назначение: Хранение крупных объектов (по умолчанию — размером >= 85 000 байт).
• Поколение: Объекты в LOH технически считаются частью поколения 2.
• Ключевые особенности:

    *   Объекты размещаются здесь сразу при создании, минуя Gen 0 и Gen 1.
    *   LOH не подвергается **уплотнению (compaction)** при каждой сборке мусора из-за высоких затрат на копирование больших блоков памяти. Это может приводить к **фрагментации**.
    *   Начиная с .NET 4.5.1, есть возможность явно запросить уплотнение LOH.
    *   Сборка мусора в LOH происходит только во время полной сборки поколения Gen 2.

Как работает алгоритм поколений

public class Example
{
    private static List<object> _longLivedList = new List<object>();

    public static void DemoGenerations()
    {
        // Объект `shortLived` создается в Gen 0
        var shortLived = new byte[500]; // Малый объект
        Console.WriteLine($"После создания (Gen 0): {GC.GetGeneration(shortLived)}");

        // Принудительная сборка мусора (только для демо, в prod так делать не нужно!)
        GC.Collect(0); // Собираем только Gen 0

        // Объект `shortLived` более не имеет корней (корневых ссылок) и будет удален.
        // Объект `_longLivedList` выживет и перейдет в Gen 1.
        Console.WriteLine($"Коллекция после использования (должна быть собрана): {GC.GetGeneration(_longLivedList)}");

        _longLivedList.Add(new object()); // Добавляем долгоживущий объект

        // Еще несколько сборок
        GC.Collect(0);
        GC.Collect(1);
        // Теперь _longLivedList, скорее всего, в Gen 2
        Console.WriteLine($"После нескольких сборок: {GC.GetGeneration(_longLivedList)}");

        // Создаем большой объект
        var largeObject = new byte[100_000]; // Попадает сразу в LOH (считается Gen 2)
        Console.WriteLine($"Большой объект: {GC.GetGeneration(largeObject)}");
    }
}

Эвристики и оптимизации GC

1. Выжившие объекты продвигаются из младшего поколения в более старшее (0 -> 1, 1 -> 2).
2. Сборка мусора запускается автоматически при:

    *   Заполнении памяти, выделенной для Gen 0.
    *   Явном вызове `GC.Collect()` (который обычно следует избегать).
    *   Нехватке физической памяти в системе.

1. Gen 0 и Gen 1 всегда уплотняются, что устраняет фрагментацию и делает выделение памяти для новых объектов невероятно быстрым (просто сдвиг указателя).
2. Сборка в одном поколении индуктивно вызывает сборку во всех более младших поколениях. Сборка Gen 1 влечет за собой сборку Gen 0, а полная сборка Gen 2 влечет за собой сборку Gen 1 и Gen 0.

Практическое значение для разработчика

• Снижайте количество долгоживущих объектов: Частые полные сборки мусора (Gen 2) негативно сказываются на производительности.
• Особое внимание LOH: Непроизвольное частое создание больших объектов (например, больших массивов, XML-строк) может вызвать фрагментацию LOH, увеличение потребления памяти и частые полные сборки мусора.
• Избегайте вызовов GC.Collect(): CLR лучше знает, когда проводить сборку. Ручные вызовы часто ухудшают производительность, нарушая тщательно настроенные эвристики.

Таким образом, разделение на поколения — это фундаментальная оптимизация в .NET GC, которая позволяет значительно снизить паузы, связанные с сборкой мусора, за счет фокусировки на наиболее вероятных кандидатах на удаление — недавно созданных объектах. Понимание этой модели необходимо для написания высокопроизводительных и отзывчивых приложений на C#.