Невывоз мусора: Не вывозят мусор, куда жаловаться? Онлайн-жалоба на невывоз мусора

Обратите внимание! Для скорейшего рассмотрения жалобы стоит прикрепить к тексту заранее сделанные фотографии, которые доказывают факт нарушения со стороны компании.

Жилищная инспекция

Жилищная инспекция — это специальный управленческий орган, который решает проблемы в работе коммунальных служб и куда можно жаловаться, если не вывозят мусор. Организация принимает жалобы от всех граждан, в письменном или электронном виде. Также возможна личная или коллективная встреча с ответственным сотрудником.

После подачи и регистрации заявления уполномоченное лицо встречается по указанному в тексте жалобы адресу с жильцами дома и коммунальными работниками для составления протокола. Далее фиксируется факт правонарушения, выдвигаются сроки для его устранения и накладываются санкции в случае невыполнения предписанного распоряжения.

Роспотребнадзор

Когда региональный оператор и управляющая компания оставляет претензии без ответа, а невывоз мусора продолжается, необходимо обратиться с жалобой в Роспотребнадзор. Письменное обращение стоит подавать лично, посетив региональное отделение службы. Можно также подать прошение о рассмотрении проблемы в электронном виде, заполнив форму обратной связи на сайте или отправив письмо на электронную почту.

Согласно законодательству, стандартный срок рассмотрения претензии составляет не более одного календарного месяца. К тексту обязательно нужно прикрепить фотографии в качестве доказательства факта нарушения, копию договора с УК и копию претензии, оставленной в Книге жалоб и предложений.

Региональные органы исполнительной власти

Региональные органы власти помогут решить вопрос, если управляющая компания и региональный оператор не соблюдают график, нарушают нормы сбора и хранения и не вывозят мусор. Куда обратиться — в городскую или районную администрацию.

К претензии необходимо приложить фотографии двора дома, прилегающих тротуаров, улицы и участка, на котором размещены контейнеры. Подать жалобу можно зарегистрировать на официальном сайте администрации, записаться на прием к руководителю через приемную или направить письмо при помощи электронной почты или в бумажном виде через почту России.

Оцените эту статью

Жители Красноярска и края жалуются на невывоз мусора

Жители Красноярска накануне праздников жалуются на захламленные мусором дворы.

Вот так, к примеру, выглядит мусорный бак одного из дворов на улице Соколовская в Солнечном:

Это фото также сделали красноярцы:

Горожан предупреждали о перебоях с вывозом мусора из-за сильных морозов: техника не выдерживает крепких холодов, отказывают механизмы.

А эта фотография сделана в Лесосибирске:

«Холодно, морозы стоят, всё понимаем, но пакеты скоро на дороге уже будут лежать! С людей так каждый месяц сбор вовремя производится, а вывозить, как мы видим, не совсем», — пишут возмущенные лесосибирцы.

А вот такая картина сейчас в мкрн Солнечный в Канске:

Жители Канска пишут, что за горой мусора уже не видно даже мусорных баков: «Время 7:25, 30 декабря 2020. Мусорные компании, сделайте свою работу!».

Вот такая картина сейчас у подъездов домов в Норильске:

А это кадр, сделанный на одной из улиц Дудинки:

«В Дудинке мусоровозы так же замёрзли, как и в Норильске. Очень странно, что в регионе, где -40 — типичная зимняя температура, никому не пришло в голову, что техника для вывоза мусора должна быть рассчитана на такие морозы», — пишут жители города.

Эти кадры сняли жители Дудинки. Силами спецтехники разросшуюся мусрную кучу сгребли боближе к мусорным бакам, чтобы пакеты с отходами не были разбросаны по всей улице:

«Новый год жители Дудинки будут встречать на свалке. Коммунальщики не работают от слова совсем. Хотя техника, как видите, не замерзает. Приехали и сгребли мусор — сделали кучу ровнее», — пишет автор видео.

Фото: vk.com/kras_sunny, «ЯЖВК», vk.com/kansklife, vk.com/typical_norilsk, vk.com/kolesolsib, vk.com/id599502392

ООО «Природа» объяснила невывоз мусора на Туркестанской отсутствием подъездных путей

ООО «Природа» отреагировало на информацию в социальных сетях. 10 ноября в интернете появились материалы о невывозе твердых коммунальных отходов (ТКО) у дома 27 по ул Туркестанской областного центра.

Вот как «Природа» объясняет причину этой ситуации: «Даже после открытия в начале ноября основной дороги до конца не были восстановлены подъездные пути и съезды во дворы жилых домов. Доступ для крупногабаритной техники к контейнерным площадкам на части адресов до сих пор перекрыт. Проехать к местам сбора ТКО было невозможно не только мусоровозам, но и легковым автомобилям в июле, августе, сентябре, о чем оператор уведомил администрацию города, минприроды региона и Государственную жилищную инспекцию области. Через управляющие компании были направлены рекомендации для жителей о выносе отходов на соседние площадки».

Для обслуживания контейнеров на Туркестанской предназначены мусоровозы Scania с задней загрузкой — крупная техника, для разворота и работы которой требуется много места, поясняют в компании. Также проезду мешают припаркованные в ряд легковые автомобили. Чтобы объехать их, не повредив, требуется заезжать на бордюр и пешеходные дорожки в нарушение ПДД. Также при узком повороте под углом 90 градусов мусоровоз не сможет совершить маневр, если поблизости припаркованы автомобили жителей.

«На сегодняшний день спецтехника через раз может проехать по адресам Туркестанская, д. 27 и д. 41. Это приводит к переполнению контейнеров и появлению хаотично складированных отходов вокруг площадок. Ситуацию иногда позволяет исправить ломовоз, более компактный по размерам и предназначенный для сбора крупногабаритных отходов (КГО), но не реже одного раза в семь дней. Иначе график вывоза КГО по другим адресам смещается», — разъяснили ситуацию в пресс-службе «Природы».

Что касается ситуации 10 ноября, Вестираму заверили: твердые коммунальные отходы на Туркестанской, д. 27 были вывезены ломовозом. Кроме того, в компании предложили жителям указанных адресов обратиться в мэрию города с запросом об оборудовании заездов для спецтехники.

Почему в таких языках, как C и C ++, нет сборки мусора, а в Java?

Реальный ответ заключается в том, что единственный способ создать безопасный и эффективный механизм сборки мусора — это иметь поддержку на уровне языка для непрозрачных ссылок. (Или, наоборот, в отсутствует поддержка на уровне языка для прямого управления памятью.)

Java и C # могут это сделать, потому что у них есть специальные ссылочные типы, которыми нельзя манипулировать. Это дает среде выполнения свободу делать такие вещи, как , перемещать выделенные объекты в памяти , что имеет решающее значение для высокопроизводительной реализации GC.

Для записи: : ни одна современная реализация GC не использует подсчет ссылок , так что это просто отвлекающий маневр. Современные сборщики мусора используют коллекцию поколений, где новые выделения обрабатываются по существу так же, как выделения стека на таком языке, как C ++, а затем периодически любые вновь выделенные объекты, которые все еще живы, перемещаются в отдельное пространство «оставшихся в живых» и целое поколение объектов освобождается сразу.

У этого подхода есть свои плюсы и минусы: положительным моментом является то, что распределение кучи на языке, поддерживающем сборщик мусора, составляет так же быстро, как выделение стека на языке, который не поддерживает сборщик мусора, а недостатком является то, что объекты, которым необходимо выполнить очистку перед уничтожаются либо требуют отдельного механизма (например,грамм. C # с использованием ключевого слова ), иначе их код очистки выполняется недетерминированно.

Обратите внимание, что одним из ключей к высокопроизводительному сборщику мусора является необходимость наличия языковой поддержки для специального класса ссылок. C не имеет этой поддержки языка и никогда не будет; поскольку C ++ имеет перегрузку операторов, он может имитировать тип указателя GC, хотя это должно быть сделано осторожно. Фактически, когда Microsoft изобрела свой диалект C ++, который будет работать в среде CLR (среда выполнения .NET), им пришлось изобрести новый синтаксис для «ссылок в стиле C #» (e.), чтобы отличать их от «ссылок в стиле C ++» (например, Foo и ).

Что есть в C ++ и что регулярно используется программистами на C ++, так это интеллектуальных указателя , которые на самом деле являются просто механизмом подсчета ссылок. Я бы не стал считать подсчет ссылок «истинным» сборщиком мусора, но он дает многие из тех же преимуществ за счет более низкой производительности, чем ручное управление памятью или настоящий сборщик мусора, но с преимуществом детерминированного уничтожения.

В конце концов, ответ действительно сводится к особенностям языкового дизайна.C сделал один выбор, C ++ сделал выбор, который позволил ему быть обратно совместимым с C, но при этом предоставить альтернативы, которые достаточно хороши для большинства целей, а Java и C # сделали другой выбор, который несовместим с C, но также достаточно хорош для большинство целей. К сожалению, серебряной пули нет, но знание различных вариантов поможет вам выбрать правильный вариант для той программы, которую вы сейчас пытаетесь создать.

данных — почему сборка мусора очищает только кучу?

Переверните свой вопрос.Настоящий мотивирующий вопрос — , при каких обстоятельствах мы можем избежать затрат на сборку мусора?

Ну, во-первых, какие — это затраты на сборку мусора? Есть два основных вида затрат. Во-первых, вы должны определить, что является живым ; это требует потенциально много работы. Во-вторых, вам нужно уплотнить отверстия , которые образуются, когда вы освобождаете что-то, что было размещено между двумя объектами, которые все еще живы. Эти дыры расточительны.Но и уплотнять их тоже дорого.

Как избежать этих затрат?

Очевидно, что если вы можете найти схему использования хранилища, в которой вы никогда не выделяете что-то долгоживущее, затем выделяете что-то недолговечное, а затем выделяете что-то долгоживущее, вы можете исключить стоимость дыр. Если вы можете гарантировать, что для некоторого подмножества вашего хранилища каждое последующее выделение будет короче, чем предыдущее в этом хранилище, то в этом хранилище никогда не будет дыр.

Но если мы решили проблему с дырками, то мы решили и проблему со сборкой мусора . У вас есть что-то живое в этом хранилище? Да. Было ли все выделенное до этого долговечным? Да — это предположение — то, как мы устранили возможность дыр. Поэтому все, что вам нужно сделать, это сказать: «живы ли самые последние выделения?» и вы знаете, что все, что живо в этом хранилище.

Есть ли у нас набор распределений памяти, при котором мы знаем, что каждое последующее выделение короче предыдущего? Да! Кадры активации методов всегда уничтожаются в порядке, обратном тому, в котором они были созданы, потому что они всегда короче, чем активация, которая их создала.

Таким образом, мы можем хранить кадры активации в стеке и знать, что их никогда не нужно собирать. Если в стеке есть какой-либо фрейм, весь набор фреймов под ним является более долговечным, поэтому их не нужно собирать. И они будут уничтожены в порядке, обратном их созданию. Таким образом, исключаются затраты на сборку мусора для фреймов активации.

Вот почему у нас в первую очередь есть временный пул в стеке: потому что это простой способ реализовать активацию метода без ущерба для управления памятью.

(Конечно, стоимость сбора мусора в памяти , указанная на по ссылкам на кадры активации, все еще существует.)

Теперь рассмотрим систему потока управления, в которой кадры активации , а не уничтожаются в предсказуемом порядке. Что произойдет, если кратковременная активация может вызвать долгоживущую активацию? Как вы можете себе представить, в этом мире вы больше не можете использовать стек, чтобы избавиться от необходимости собирать активации. Набор активаций снова может содержать дыры.

C # 2.0 имеет эту функцию в виде yield return . Метод, возвращающий yield, будет повторно активирован позже — при следующем вызове MoveNext — и когда это произойдет, предсказать невозможно. Поэтому информация, которая обычно находится в стеке для кадра активации блока итератора, вместо этого хранится в куче, где она собирается мусором при сборе перечислителя.

Точно так же функция «async / await», которая появится в следующих версиях C # и VB, позволит вам создавать методы, активация которых «дает результат» и «возобновляет» в четко определенных точках во время действия метода.Поскольку кадры активации больше не создаются и не уничтожаются предсказуемым образом, вся информация, которая раньше хранилась в стеке, должна храниться в куче.

Это просто историческая случайность, что на протяжении нескольких десятилетий мы решили, что языки с фреймами активации, которые создаются и уничтожаются строго упорядоченным образом, являются модными. Поскольку в современных языках все чаще отсутствует это свойство, ожидайте увидеть все больше и больше языков, которые реифицируют продолжения в куче со сборкой мусора, а не в стеке.

Последний рубеж производительности Java: удаление сборщика мусора

Алексей Шипилев, разработчик производительности и OpenJDK в RedHat, подал новый проект JEP для создания бесполезного сборщика мусора; то есть сборщик мусора, который на самом деле не восстанавливает память. Этот сборщик нацелен на помощь разработчикам и исследователям JVM и, в меньшей степени, но, возможно, более интересен для общедоступных, сверхпроизводительных приложений, которые практически не генерируют мусора. Если JEP будет продолжен, новый сборщик мусора будет доступен вместе с существующими и не будет иметь никакого эффекта, если явно не активирован.

Сборка мусора и производительность Java — всегда сложная тема для решения, и, чтобы помочь прояснить ситуацию, InfoQ обратилась к чемпионам по Java и экспертам по производительности Мартину Вербургу и Кирку Пеппердайну. Мы также поговорили с Ремко Попмой, который руководит преобразованием Log4j без мусора, о том, как можно достичь этой цели. Вербург и Попма подтвердили, что, по их мнению, главными бенефициарами безоперационного GC, или Epsilon GC, как его еще называют, будут разработчики GC и исследователи производительности.Epsilon GC может служить контрольной переменной для измерения производительности других сборщиков мусора. В качестве упрощенного примера, у нас может быть приложение, работающее с безоперационным сборщиком мусора, для уменьшения накладных расходов на сборщик мусора (исключая другие соображения о распределении памяти и управлении мутациями). Если то же приложение затем запускается с той же рабочей нагрузкой, но с разными настроенными алгоритмами сборки мусора, разница в производительности будет указывать на влияние сборщика мусора на приложение. Это поможет разработчикам сборщиков мусора и исследователям производительности более изолированно понять поведение сборщиков мусора.

«Я думаю, что это действительно большой шаг вперед для обеспечения более точного тестирования различных частей JVM (таких как существующие компиляторы JIT C1 / C2, возможный переход на Graal и т. Д.). Это действительно добавит дополнительной долговечности для JVM «. Мартин Вербург

С другой стороны, Epsilon GC может выиграть от сверхпроизводительных приложений. Существует редкое поколение приложений и библиотек, таких как вышеупомянутый Log4j, которые были реализованы таким образом, что они не производят мусора и, следовательно, не нуждаются в сборщике мусора; для этого типа приложений производительность может быть улучшена за счет устранения накладных расходов на сборщик.Однако, как подчеркнул Попма, создание библиотеки, которая может работать с Epsilon GC, «потребует значительных инженерных усилий, чтобы убедиться, что память приложения управляется достаточно тщательно, чтобы она не закончилась», и даже тогда оценка рисков и выгод должна Чтобы убедиться, что выигрыш, полученный при выборе бесполезного сборщика мусора, согласуется со сложностью достижения состояния с нулевым мусором.

Однако может показаться трудным представить себе, как приложение может быть написано так, чтобы не создавать мусора, и хотя тема намного сложнее, чем то, что можно было бы объяснить в этой статье, ее может быть легче понять, приняв во внимание следующие соображения:

• Память в JVM управляется двумя разными механизмами: кучей и стеком; вот почему есть две разные ошибки, связанные с нехваткой памяти ( OutOfMemoryError и StackOverflowError ).Память, размещенная в стеке, видна только текущему потоку и во время выполнения текущего метода; поэтому, когда текущий поток покидает текущий метод, эта память автоматически освобождается без использования сборщика мусора. Однако память в куче доступна для всего приложения в любой момент, что означает, что независимый сборщик мусора должен проверять, когда часть памяти больше не используется и может быть освобождена.
• Выделение примитивов всегда происходит в стеке, поэтому сборщик мусора не оказывает никакого давления.Если бы кто-то писал код, используя в основном примитивные типы, сборщик мусора мог бы заботиться о меньшем количестве объектов.
• Не производить мусора — не то же самое, что не производить никаких предметов; объекты по-прежнему могут быть созданы без необходимости в сборщике мусора, который будет заботиться о них:
  • Приложение или библиотека могут вначале создавать несколько объектов, а затем постоянно их повторно использовать; для этого разработчик должен очень хорошо понимать объем памяти, занимаемый приложением.
  • Иногда компилятор может понять, что конкретный объект не будет использоваться вне метода; это известно как анализ побега. Когда обнаруживается, что объект не покидает метод, он может быть размещен в стеке, а не в куче, и поэтому автоматически удаляется, как только текущий метод завершается.

Хотя все это возможно, Пеппердайн указал, что это очень неестественный способ написания кода, который подразумевает потерю многих преимуществ, которые предоставляет Java, в то время как Вербург также указал, что управление памятью является как раз одной из основных причин, по которым Java имеет был настолько успешным в отрасли.В дополнение к этому, мы должны иметь в виду, что, несмотря на свое название, сборщик мусора не только выполняет задачу восстановления неиспользуемой памяти, но и выделяет новые блоки, и Epsilon GC все равно придется это делать. Pepperdine использует этот аргумент, чтобы предположить, что, по крайней мере теоретически, не будет значительной разницы в производительности между использованием Epsilon GC и любым другим алгоритмом сборки мусора, настроенным до такой степени, что он фактически не выполняет сборку мусора.

Однако, даже учитывая все эти предостережения, и Пеппердин, и Вербург подтвердили, что существует небольшая аудитория, для которой такое поведение может быть очень полезным, но тот факт, что эта аудитория мала, по словам Кирка, вызывает сомнения в ее полезности.Подавляющему большинству приложений в какой-то момент требуется освободить память, и поэтому им нужен функциональный сборщик мусора.

«Разумное время паузы GC просто не проблема для большинства приложений, так зачем отказываться от всех преимуществ Java ради сомнительного выигрыша в производительности». Кирк Пеппердин

Pepperdine также напомнил нам, что каждая новая функция увеличивает затраты на обслуживание OpenJDK, и поэтому разработчики OpenJDK должны учитывать общую картину при их добавлении.Oracle сокращает количество доступных сборщиков мусора именно для снижения затрат на обслуживание, и поэтому добавление GC, который будет полезен только небольшому проценту пользователей, может не представлять правильных инвестиций. Шипилев, похоже, учел эти моменты при подаче черновика JEP, и предварительный анализ, кажется, показывает, что накладные расходы будут минимальными в этом случае, судя по содержанию черновика JEP и прототипу, который уже был предоставлен. Фактически, и Пеппердин, и Вербург указали, что, учитывая опыт Шипилёва, тот факт, что он возглавляет эту инициативу, является достаточной причиной для оптимизма.

С другой стороны, Pepperdine также подчеркнул тот факт, что, хотя OpenJDK является эталонной реализацией JVM, нет требований к совместимости сборщика мусора, что означает, что поставщики могут реализовывать свои собственные алгоритмы и при этом быть полностью совместимыми со стандартной Java. . Это может вызвать разделение мнений среди общественности: хотя некоторые могут подумать, что реализация алгоритмов для нишевых рынков может быть чем-то более подходящим для коммерческих версий JVM, другие могут посчитать это очень полезным дополнением к OpenJDK.

@shipilev Zing на самом деле не имеет опции GC. Это очень полезно для тестирования. Некоторым людям понравится этот вариант в OpenJDK.

— Ницан Вакарт (@nitsanw) 12 февраля 2017 г.

Popma также рекомендовала, по крайней мере, рассмотреть возможность использования коммерческих JVM, когда производительность становится критической, поскольку стоимость лицензии на один из этих продуктов в целом может быть ниже, чем затраты на выбор и настройку конкретного алгоритма GC техническим персоналом. Однако, даже если кто-то был настроен на использование только технологий OpenJDK, и Попма, и Вербург упомянули находящийся в настоящее время в разработке Shenandoah GC, который нацелен на создание сверхнизкого времени паузы для очень больших куч (100 ГБ или более).В любом случае эксперты пришли к единому мнению, что когда дело доходит до производительности приложения, тщательно подобранный алгоритм GC почти всегда будет лучше, чем отсутствие GC вообще.

Это предложение еще только начинается, и его нужно пересмотреть и отполировать, прежде чем оно станет официальным JEP. Когда и если это произойдет, к нему в конечном итоге будет добавлена ​​целевая версия. Хотя в настоящее время мы можем только предполагать, какой может быть эта целевая версия, Вербург считает, что разумно ожидать, что Epsilon GC будет готов для Java 10 или 11.Во всяком случае, это, по крайней мере, помогло бы понять, каким должен быть интерфейс GC, способствуя более модульной JVM.

Что это такое и как это работает — Stackify

Python — один из самых популярных языков программирования, и его использование продолжает расти. Он занял третье место на языке TIOBE в 2021 году благодаря темпам роста. Простота использования Python и большое сообщество сделали его популярным для анализа данных, веб-приложений и автоматизации задач.

В этом посте мы подробно рассмотрим сборку мусора в Python.Сначала мы рассмотрим основы управления памятью и то, зачем нам нужна сборка мусора. Затем мы посмотрим, как Python реализует сборку мусора. Наконец, мы на практике рассмотрим, как следует относиться к сборке мусора при написании приложений Python.

Что такое сборщик мусора Python и зачем он нам нужен?

Если Python — ваш первый язык программирования, сама идея сборки мусора может быть вам чужда. Начнем с основ.

Управление памятью

Язык программирования использует объекты в своих программах для выполнения операций. Объекты включают простые переменные, такие как строки, целые числа или логические значения. Они также включают более сложные структуры данных, такие как списки, хэши или классы.

Значения объектов вашей программы хранятся в памяти для быстрого доступа. Во многих языках программирования переменная в вашем программном коде — это просто указатель на адрес объекта в памяти. Когда переменная используется в программе, процесс будет считывать значение из памяти и работать с ним.

В ранних языках программирования большинство разработчиков отвечали за управление памятью в своих программах. Это означало, что перед созданием списка или объекта вам сначала нужно было выделить память для вашей переменной. После того, как вы закончили работу с переменной, вам нужно было освободить ее, чтобы «освободить» эту память для других пользователей.

Это привело к двум проблемам:

1. Забыть освободить память . Если вы не освободите память, когда закончите ее использовать, это может привести к утечке памяти.Это может со временем привести к тому, что ваша программа будет использовать слишком много памяти. Для долго работающих приложений это может вызвать серьезные проблемы.
2. Слишком быстрое освобождение памяти . Второй тип проблем заключается в освобождении вашей памяти, пока она еще используется. Это может привести к сбою вашей программы при попытке доступа к несуществующему значению в памяти или к повреждению ваших данных. Переменная, которая ссылается на освобожденную память, называется висячим указателем.

Эти проблемы были нежелательными, поэтому в новых языках добавлено автоматическое управление памятью.

Автоматическое управление памятью и сборка мусора

Благодаря автоматическому управлению памятью программистам больше не нужно самостоятельно управлять памятью. Скорее, среда выполнения сделала это за них.

Существует несколько различных методов автоматического управления памятью. Популярные используют подсчет ссылок. При подсчете ссылок среда выполнения отслеживает все ссылки на объект. Когда объект не имеет ссылок на него, он непригоден для использования программным кодом и может быть удален.

Для программистов автоматическое управление памятью дает ряд преимуществ. Быстрее разрабатывать программы, не задумываясь о деталях низкоуровневой памяти. Кроме того, это может помочь избежать дорогостоящих утечек памяти или опасных висячих указателей.

Однако автоматическое управление памятью требует затрат. Вашей программе потребуется дополнительная память и вычисления для отслеживания всех своих ссылок. Более того, многие языки программирования с автоматическим управлением памятью используют процесс «остановки мира» для сборки мусора, когда все выполнение останавливается, пока сборщик мусора ищет и удаляет объекты, подлежащие сборке.

С развитием компьютерной обработки в соответствии с законом Мура и увеличением объема оперативной памяти в новых компьютерах, преимущества автоматического управления памятью обычно перевешивают недостатки. Таким образом, большинство современных языков программирования, таких как Java, Python и Golang, используют автоматическое управление памятью.

Для долго работающих приложений, где производительность критична, на некоторых языках все еще есть ручное управление памятью. Классическим примером этого является C ++. Мы также видим ручное управление памятью в Objective-C, языке, используемом для macOS и iOS.Для новых языков Rust использует ручное управление памятью.

Теперь, когда мы знаем об управлении памятью и сборке мусора в целом, давайте более подробно рассмотрим, как работает сборка мусора Python.

Попробуйте бесплатный профилировщик кода Prefix от Stackify, чтобы написать лучший код на своей рабочей станции. Префикс работает с .NET, Java, PHP, Node.js, Ruby и Python.

Как Python реализует сборку мусора

В этом разделе мы рассмотрим, как сборка мусора работает в Python.

В этом разделе предполагается, что вы используете реализацию Python для CPython. CPython — наиболее широко используемая реализация. Однако существуют и другие реализации Python, такие как PyPy, Jython (на основе Java) или IronPython (на основе C #).

Чтобы узнать, какой Python вы используете, выполните следующую команду в своем терминале (Linux):

 >>> python -c 'import platform; печать (platform.python_implementation ()) '

Или вы можете использовать эти строки как для терминалов Linux, так и для Windows.>>> импортная платформа
>>> print (platform.python_imlplementation ())
CPython 

В CPython есть два аспекта управления памятью и сборки мусора:

• Подсчет ссылок
• Сборка мусора поколений

Давайте рассмотрим каждый из них ниже.

Подсчет ссылок в CPython

Основным механизмом сборки мусора в CPython является подсчет ссылок. Всякий раз, когда вы создаете объект в Python, базовый объект C имеет как тип Python (например, список, dict или функция), так и счетчик ссылок.

На самом базовом уровне счетчик ссылок на объект Python увеличивается при каждой ссылке на объект и уменьшается при разыменовании объекта. Если счетчик ссылок на объект равен 0, память для этого объекта освобождается.

Код вашей программы не может отключить подсчет ссылок Python. Это контрастирует с поколенческим сборщиком мусора, обсуждаемым ниже.

Некоторые утверждают, что подсчет ссылок — это сборщик мусора для бедняков. У него есть некоторые недостатки, в том числе невозможность обнаруживать циклические ссылки, как описано ниже.Однако подсчет ссылок удобен тем, что вы можете немедленно удалить объект, если на него нет ссылок.

Просмотр счетчиков ссылок в Python

Вы можете использовать модуль sys из стандартной библиотеки Python для проверки счетчиков ссылок для определенного объекта. Есть несколько способов увеличить счетчик ссылок для объекта, например

• Назначение объекта переменной.
• Добавление объекта в структуру данных, например добавление в список или добавление в качестве свойства экземпляра класса.
• Передача объекта в качестве аргумента функции.

Давайте воспользуемся Python REPL и модулем sys, чтобы увидеть, как обрабатываются счетчики ссылок.

Сначала в терминале введите python , чтобы войти в Python REPL.

Во-вторых, импортируйте модуль sys в свой REPL. Затем создайте переменную и проверьте ее количество ссылок:

 >>> import sys 
 >>> a = 'my-string' 
 >>> sys.getrefcount (a) 
 2 

Обратите внимание, что есть две ссылки на наша переменная a .Один — от создания переменной. Второй — когда мы передаем переменную a в функцию sys.getrefcount () .

Если вы добавите переменную в структуру данных, такую ​​как список или словарь, вы увидите увеличение количества ссылок:

 >>> import sys 
 >>> a = 'my-string' 
 >> > b = [a] # Составьте список с a в качестве элемента. 
 >>> c = {'key': a} # Создать словарь с a в качестве одного из значений. 
 >>> sys.getrefcount (a) 
 4 

Как показано выше, счетчик ссылок от до увеличивается при добавлении в список или словарь.

В следующем разделе мы узнаем о сборщике мусора поколений, который является вторым инструментом, который Python использует для управления памятью.

Сборка мусора поколений

Помимо стратегии подсчета ссылок для управления памятью, Python также использует метод, называемый сборщиком мусора поколений.

Самый простой способ понять, зачем нам нужен сборщик мусора поколений, — это на примере.

В предыдущем разделе мы видели, что добавление объекта в массив или объект увеличивает его счетчик ссылок. Но что произойдет, если вы добавите объект к самому себе?

 >>> class MyClass (object): 
 ... pass 
 ... 
 >>> a = MyClass () 
 >>> a.obj = a 
 >>> del a 

В примере выше , мы определили новый класс. Затем мы создали экземпляр класса и назначили этот экземпляр свойством самого себя. Наконец, мы удалили экземпляр.

После удаления экземпляра он больше не будет доступен в нашей программе Python. Однако Python не уничтожил экземпляр по памяти. У экземпляра нет нулевого счетчика ссылок, потому что он ссылается на самого себя.

Мы называем этот тип проблем циклом обращений, и вы не можете решить их с помощью подсчета обращений. Это основная задача сборщика мусора поколений, который доступен модулю gc в стандартной библиотеке.

Терминология сборщика мусора поколений

Есть две ключевые концепции, которые следует понимать при работе со сборщиком мусора поколений.

1. Первая концепция — это концепция поколения.
2. Второе ключевое понятие — это порог.

Сборщик мусора отслеживает все объекты в памяти. Новый объект начинает свою жизнь в первом поколении сборщика мусора. Если Python выполняет процесс сборки мусора для одного поколения и объект выживает, он переходит во второе, более старое поколение. У сборщика мусора Python всего три поколения, и объект переходит в старшее поколение всякий раз, когда он выживает в процессе сборки мусора в своем текущем поколении.

Для каждого поколения модуль сборщика мусора имеет пороговое количество объектов. Если количество объектов превышает этот порог, сборщик мусора запускает процесс сбора. Любые объекты, пережившие этот процесс, переходят в старшее поколение.

В отличие от механизма подсчета ссылок, вы можете изменить поведение сборщика мусора поколений в вашей программе Python. Это включает изменение пороговых значений для запуска процесса сборки мусора в вашем коде.Кроме того, вы можете вручную запустить процесс сборки мусора или полностью отключить процесс сборки мусора.

Давайте посмотрим, как можно использовать модуль gc для проверки статистики сборки мусора или изменения поведения сборщика мусора.

Использование модуля GC

В терминале введите python , чтобы перейти в Python REPL.

Импортируйте модуль gc в свой сеанс. Затем вы можете проверить настроенные пороги вашего сборщика мусора с помощью метода get_threshold () :

 >>> import gc 
 >>> gc.get_threshold () 
 (700, 10, 10) 

По умолчанию Python имеет порог 700 для самого молодого поколения и 10 для каждого из двух старших поколений.

Вы можете проверить количество объектов в каждом из ваших поколений с помощью метода get_count () :

 >>> import gc 
 >>> gc.get_count () 
 (596, 2, 1) 

In В этом примере у нас есть 596 объектов в нашем самом молодом поколении, два объекта в следующем поколении и один объект в самом старом поколении.

Как видите, Python по умолчанию создает ряд объектов еще до того, как вы начнете выполнять свою программу. Вы можете запустить процесс сборки мусора вручную с помощью метода gc.collect () :

 >>> gc.get_count ()
(595, 2, 1)
>>> gc.collect ()
577
>>> gc.get_count ()
(18, 0, 0) 

Запуск процесса сборки мусора очищает огромное количество объектов — 577 объектов в первом поколении и еще три в старших поколениях.

Вы можете изменить пороговые значения для запуска сборки мусора с помощью метода set_threshold () в модуле gc:

 >>> import gc 
 >>> gc.get_threshold () 
 (700, 10, 10) 
 >>> gc.set_threshold (1000, 15, 15) 
 >>> gc.get_threshold () 
 (1000, 15, 15) 

В приведенном выше примере мы увеличиваем каждый из наших пороговых значений по сравнению с их значениями по умолчанию. Увеличение порога снизит частоту запуска сборщика мусора.Это будет менее затратно с точки зрения вычислений в вашей программе за счет более длительного хранения мертвых объектов.

Теперь, когда вы знаете, как работают и подсчет ссылок, и модуль сборщика мусора, давайте обсудим, как вы должны использовать это при написании приложений Python.

Что означает сборщик мусора Python для вас как разработчика

Мы потратили немало времени на обсуждение управления памятью в целом и его реализацию на Python. Пришло время сделать его полезным.Как вы должны использовать эту информацию как разработчик программ на Python?

Общее правило: не меняйте поведение сборщика мусора

Как правило, вам, вероятно, не следует слишком много думать о сборщике мусора Python. Одним из ключевых преимуществ Python является повышение производительности труда разработчиков. Отчасти это связано с тем, что это язык высокого уровня, который обрабатывает для разработчика ряд деталей низкого уровня.

Ручное управление памятью больше подходит для сред с ограничениями.Если вы действительно столкнетесь с ограничениями производительности, которые, по вашему мнению, могут быть связаны с механизмами сборки мусора Python, вероятно, будет полезнее увеличить мощность вашей среды выполнения, чем вручную изменять процесс сборки мусора. В мире закона Мура, облачных вычислений и дешевой памяти больше энергии легко доступно.

Это реалистично даже с учетом того, что Python обычно не освобождает память обратно базовой операционной системе. Любой процесс ручной сборки мусора, который вы выполняете для освобождения памяти, может не дать желаемых результатов.Дополнительные сведения в этой области см. В этой публикации об управлении памятью в Python.

Отключение сборщика мусора

Если оставить в стороне это предостережение, существуют ситуации, в которых вы можете захотеть управлять процессом сборки мусора. Помните, что подсчет ссылок, основной механизм сборки мусора в Python, отключить нельзя. Единственное поведение сборки мусора, которое вы можете изменить, — это генеральный сборщик мусора в модуле gc.

Один из наиболее интересных примеров изменения сборщика мусора поколений — это отключение сборщика мусора в Instagram.

Instagram использует Django, популярный веб-фреймворк Python, для своих веб-приложений. Он запускает несколько экземпляров своего веб-приложения на одном вычислительном экземпляре. Эти экземпляры запускаются с использованием механизма «главный-дочерний», в котором дочерние процессы совместно используют память с мастером.

Команда разработчиков Instagram заметила, что общая память резко упадет вскоре после создания дочернего процесса. При дальнейшем копании увидели, что виноват сборщик мусора.

Команда Instagram отключила модуль сборщика мусора, установив пороговые значения для всех поколений равными нулю.Это изменение привело к тому, что их веб-приложения стали работать на 10% эффективнее.

Хотя этот пример интересен, убедитесь, что вы находитесь в аналогичной ситуации, прежде чем идти по тому же пути. Instagram — это веб-приложение, обслуживающее многие миллионы пользователей. Для них стоит использовать нестандартное поведение, чтобы выжать каждый дюйм производительности своих веб-приложений. Для большинства разработчиков достаточно стандартного поведения Python в отношении сборки мусора.

Если вы думаете, что можете вручную управлять сборкой мусора в Python, сначала убедитесь, что вы понимаете проблему.Используйте такие инструменты, как Stackify Retrace, для измерения производительности вашего приложения и выявления проблем. Как только вы полностью поймете проблему, примите меры по ее устранению.

Начните 14-дневную БЕСПЛАТНУЮ пробную версию сегодня!

Завершение

В этом посте мы узнали о сборке мусора Python. Мы начали с изучения основ управления памятью и создания автоматического управления памятью. Затем мы рассмотрели, как сборка мусора реализована в Python с помощью автоматического подсчета ссылок и генерального сборщика мусора.Наконец, мы рассмотрели, насколько это важно для вас как разработчика Python.

Хотя Python выполняет большую часть сложных операций по управлению памятью, все же полезно знать, что происходит под капотом. Прочитав этот пост, вы теперь знаете, что вам следует избегать циклов обращения к Python, и вы должны знать, где искать, если вам нужен больший контроль над сборщиком мусора Python.

Основы сборки мусора | Документы Microsoft

• 15.11.2019
• Читать 14 минут

В этой статье

В общеязыковой среде выполнения (CLR) сборщик мусора (GC) служит автоматическим диспетчером памяти.Сборщик мусора управляет выделением и освобождением памяти для приложения. Для разработчиков, работающих с управляемым кодом, это означает, что вам не нужно писать код для выполнения задач управления памятью. Автоматическое управление памятью может устранить распространенные проблемы, такие как забвение освобождения объекта и возникновение утечки памяти или попытка доступа к памяти для уже освобожденного объекта.

В этой статье описаны основные концепции сборки мусора.

Преимущества

Сборщик мусора обеспечивает следующие преимущества:

• Освобождает разработчиков от необходимости вручную освобождать память.

• Эффективно размещает объекты в управляемой куче.

• Восстанавливает объекты, которые больше не используются, очищает их память и сохраняет доступную для будущих распределений. Управляемые объекты автоматически получают чистый контент для начала, поэтому их конструкторам не нужно инициализировать каждое поле данных.

• Обеспечивает безопасность памяти, гарантируя, что объект не может использовать содержимое другого объекта.

Основы памяти

В следующем списке приведены важные концепции памяти CLR.

• Каждый процесс имеет собственное отдельное виртуальное адресное пространство. Все процессы на одном компьютере используют одну и ту же физическую память и файл подкачки, если он есть.

• По умолчанию на 32-разрядных компьютерах каждый процесс имеет виртуальное адресное пространство пользовательского режима размером 2 ГБ.

• Как разработчик приложений вы работаете только с виртуальным адресным пространством и никогда не манипулируете физической памятью напрямую. Сборщик мусора выделяет и освобождает виртуальную память в управляемой куче.

  Если вы пишете собственный код, вы используете функции Windows для работы с виртуальным адресным пространством. Эти функции выделяют и освобождают виртуальную память в собственных кучах.

• Виртуальная память может находиться в трех состояниях:

  Государство	Описание
  Бесплатно	Блок памяти не имеет ссылок на него и доступен для распределения.
  Зарезервировано	Блок памяти доступен для вашего использования и не может использоваться для других запросов на выделение.Однако вы не можете сохранять данные в этом блоке памяти, пока они не будут зафиксированы.
  Выполнено	Блок памяти назначен физическому хранилищу.

• Виртуальное адресное пространство может быть фрагментированным. Это означает, что в адресном пространстве есть свободные блоки, также известные как дыры. Когда запрашивается выделение виртуальной памяти, диспетчер виртуальной памяти должен найти единственный свободный блок, достаточно большой, чтобы удовлетворить этот запрос на выделение.Даже если у вас есть 2 ГБ свободного места, выделение, для которого требуется 2 ГБ, будет неудачным, если все это свободное пространство не будет в одном адресном блоке.

• У вас может закончиться память, если не хватает виртуального адресного пространства для резервирования или физического пространства для фиксации.

  Файл подкачки используется, даже если нехватка физической памяти (то есть потребность в физической памяти) низка. В первый раз, когда нагрузка на физическую память высока, операционная система должна освободить место в физической памяти для хранения данных, и она выполняет резервное копирование некоторых данных, находящихся в физической памяти, в файл подкачки.Эти данные не выгружаются на страницы до тех пор, пока они не понадобятся, поэтому возможно столкновение с разбиением на страницы в ситуациях, когда физическая нагрузка на память невысока.

Распределение памяти

Когда вы инициализируете новый процесс, среда выполнения резервирует непрерывную область адресного пространства для процесса. Это зарезервированное адресное пространство называется управляемой кучей. Управляемая куча поддерживает указатель на адрес, по которому будет размещен следующий объект в куче. Первоначально этот указатель устанавливается на базовый адрес управляемой кучи.Все ссылочные типы размещены в управляемой куче. Когда приложение создает первый ссылочный тип, для этого типа выделяется память по базовому адресу управляемой кучи. Когда приложение создает следующий объект, сборщик мусора выделяет для него память в адресном пространстве, которое следует сразу за первым объектом. Пока доступно адресное пространство, сборщик мусора продолжает таким образом выделять пространство для новых объектов.

Выделение памяти из управляемой кучи выполняется быстрее, чем выделение неуправляемой памяти.Поскольку среда выполнения выделяет память для объекта, добавляя значение к указателю, это почти так же быстро, как выделение памяти из стека. Кроме того, поскольку новые объекты, которые выделяются последовательно, непрерывно хранятся в управляемой куче, приложение может быстро получить доступ к объектам.

Выпуск памяти

Механизм оптимизации сборщика мусора определяет наилучшее время для выполнения сборки на основе выполняемых распределений. Когда сборщик мусора выполняет сборку, он освобождает память для объектов, которые больше не используются приложением.Он определяет, какие объекты больше не используются, проверяя корней приложения. Корни приложения включают статические поля, локальные переменные в стеке потока, регистры ЦП, дескрипторы сборщика мусора и очередь финализации. Каждый корень либо ссылается на объект в управляемой куче, либо имеет значение null. Сборщик мусора может запросить эти корни у остальной среды выполнения. Используя этот список, сборщик мусора создает граф, содержащий все объекты, доступные из корней.

Объекты, которых нет в графе, недоступны из корней приложения. Сборщик мусора считает недостижимые объекты мусором и освобождает выделенную для них память. Во время сборки сборщик мусора проверяет управляемую кучу в поисках блоков адресного пространства, занятых недоступными объектами. Обнаруживая каждый недостижимый объект, он использует функцию копирования памяти для сжатия доступных объектов в памяти, освобождая блоки адресных пространств, выделенные для недоступных объектов.После сжатия памяти для доступных объектов сборщик мусора вносит необходимые исправления в указатель, чтобы корни приложения указывали на объекты в их новых местах. Он также помещает указатель управляемой кучи после последнего достижимого объекта.

Память сжимается, только если коллекция обнаруживает значительное количество недостижимых объектов. Если все объекты в управляемой куче выживают в коллекции, то в уплотнении памяти нет необходимости.

Для повышения производительности среда выполнения выделяет память для больших объектов в отдельной куче.Сборщик мусора автоматически освобождает память для больших объектов. Однако, чтобы избежать перемещения больших объектов в памяти, эта память обычно не сжимается.

Условия сборки мусора

Сборка мусора происходит при выполнении одного из следующих условий:

• В системе мало физической памяти. Это обнаруживается либо по уведомлению о нехватке памяти от ОС, либо по нехватке памяти, как указывается хостом.

• Объем памяти, используемый выделенными объектами в управляемой куче, превышает допустимый порог.Этот порог постоянно корректируется по мере выполнения процесса.

• Вызывается метод GC.Collect. Практически во всех случаях вам не нужно вызывать этот метод, потому что сборщик мусора работает непрерывно. Этот метод в основном используется для уникальных ситуаций и тестирования.

Управляемая куча

После инициализации сборщика мусора средой CLR он выделяет сегмент памяти для хранения объектов и управления ими. Эта память называется управляемой кучей, в отличие от собственной кучи в операционной системе.

Для каждого управляемого процесса есть управляемая куча. Все потоки в процессе выделяют память для объектов в одной куче.

Чтобы зарезервировать память, сборщик мусора вызывает функцию Windows VirtualAlloc и резервирует по одному сегменту памяти для управляемых приложений. Сборщик мусора также резервирует сегменты по мере необходимости и возвращает сегменты операционной системе (после очистки их от любых объектов) путем вызова функции Windows VirtualFree.

Важно

Размер сегментов, выделяемых сборщиком мусора, зависит от реализации и может изменяться в любое время, в том числе при периодических обновлениях.Ваше приложение никогда не должно делать предположений или зависеть от определенного размера сегмента, а также не должно пытаться настроить объем памяти, доступный для выделения сегментов.

Чем меньше объектов размещено в куче, тем меньше работы должен выполнять сборщик мусора. При размещении объектов не используйте округленные значения, превышающие ваши потребности, например выделение массива из 32 байтов, когда вам нужно всего 15 байтов.

Когда запускается сборщик мусора, сборщик мусора освобождает память, занятую мертвыми объектами.В процессе регенерации живые объекты уплотняются так, что они перемещаются вместе, а мертвое пространство удаляется, тем самым уменьшая размер кучи. Это гарантирует, что объекты, которые размещены вместе, останутся вместе в управляемой куче, чтобы сохранить свою локальность.

Интрузивность (частота и продолжительность) сборок мусора является результатом объема выделений и количества оставшейся памяти в управляемой куче.

Кучу можно рассматривать как скопление двух куч: кучи больших объектов и кучи малых объектов.Куча больших объектов содержит объекты размером 85 000 байт и более, которые обычно являются массивами. Экземплярный объект редко бывает очень большим.

Поколения

Алгоритм GC основан на нескольких соображениях:

• Сжать память для части управляемой кучи быстрее, чем для всей управляемой кучи.
• Более новые объекты имеют более короткий срок службы, а более старые объекты — более длительный срок службы.
• Более новые объекты, как правило, связаны друг с другом и доступны для приложения примерно в одно и то же время.

Сборка мусора в основном происходит с восстановлением недолговечных объектов. Чтобы оптимизировать производительность сборщика мусора, управляемая куча разделена на три поколения: 0, 1 и 2, поэтому она может обрабатывать долгоживущие и короткоживущие объекты отдельно. Сборщик мусора хранит новые объекты в поколении 0. Объекты, созданные на ранних этапах жизненного цикла приложения, которые выживают в коллекциях, продвигаются и сохраняются в поколениях 1 и 2. Поскольку сжатие части управляемой кучи происходит быстрее, чем всей кучи, эта схема позволяет сборщик мусора, чтобы освобождать память в определенном поколении, а не освобождать память для всей управляемой кучи каждый раз, когда он выполняет сборку.

• Поколение 0 . Это самое молодое поколение, содержащее недолговечные объекты. Примером недолговечного объекта является временная переменная. В этом поколении сборка мусора происходит чаще всего.

  Недавно размещенные объекты образуют новое поколение объектов и неявно являются коллекциями поколения 0. Однако, если это большие объекты, они помещаются в кучу больших объектов (LOH), которую иногда называют поколения 3 . Поколение 3 — это физическое поколение, которое логически собирается как часть поколения 2.

  Большинство объектов возвращаются для сборки мусора в поколении 0 и не доживают до следующего поколения.

  Если приложение пытается создать новый объект, когда поколение 0 заполнено, сборщик мусора выполняет сборку, пытаясь освободить адресное пространство для объекта. Сборщик мусора начинает с проверки объектов в поколении 0, а не всех объектов в управляемой куче. Одна только коллекция поколения 0 часто освобождает достаточно памяти, чтобы приложение могло продолжать создавать новые объекты.

• Поколение 1 . Это поколение содержит короткоживущие объекты и служит буфером между короткоживущими и долгоживущими объектами.

  После того, как сборщик мусора выполняет сборку для поколения 0, он сжимает память для доступных объектов и продвигает их до поколения 1. Поскольку объекты, которые выживают при сборках, как правило, имеют более длительный срок службы, имеет смысл повысить их до более высокого поколения. Сборщику мусора не нужно повторно проверять объекты в поколениях 1 и 2 каждый раз, когда он выполняет сборку поколения 0.

  Если коллекция поколения 0 не освобождает достаточно памяти для приложения, чтобы создать новый объект, сборщик мусора может выполнить сборку поколения 1, затем поколения 2. Объекты в поколении 1, которые выживают после сборок, повышаются до поколения 2.

• Поколение 2 . Это поколение содержит долгоживущие объекты. Примером долгоживущего объекта является объект в серверном приложении, который содержит статические данные, которые существуют в течение всего процесса.

  Объекты в поколении 2, которые выживают в коллекции, остаются в поколении 2 до тех пор, пока они не будут определены как недоступные в будущей коллекции.

  Объекты в куче больших объектов (которую иногда называют поколение 3 ) также собираются в поколении 2.

Сборка мусора происходит на определенных поколениях в зависимости от условий. Собирать поколение означает собирать предметы в этом поколении и во всех его младших поколениях.Сборка мусора поколения 2 также известна как полная сборка мусора, поскольку она освобождает объекты всех поколений (то есть все объекты в управляемой куче).

Выживание и акции

Объекты, которые не восстанавливаются при сборке мусора, называются выжившими и переходят в следующее поколение:

• Объекты, которые пережили сборку мусора поколения 0, повышаются до поколения 1.
• Объекты, которые пережили сборку мусора поколения 1, переводятся в поколение 2.
• Объекты, которые пережили сборку мусора поколения 2, остаются в поколении 2.

Когда сборщик мусора обнаруживает высокую выживаемость в поколении, он увеличивает порог выделения для этого поколения. Следующая коллекция получает значительный объем восстановленной памяти. CLR постоянно уравновешивает два приоритета: не позволять рабочему набору приложения становиться слишком большим, откладывая сборку мусора, и не позволять сборке мусора запускаться слишком часто.

Эфемерные поколения и сегменты

Поскольку объекты в поколениях 0 и 1 недолговечны, эти поколения известны как эфемерные поколения .

Эфемерные поколения выделяются в сегменте памяти, который известен как эфемерный сегмент. Каждый новый сегмент, полученный сборщиком мусора, становится новым эфемерным сегментом и содержит объекты, которые пережили сборку мусора поколения 0. Старый эфемерный сегмент становится сегментом нового поколения 2.

Размер эфемерного сегмента зависит от того, является ли система 32-битной или 64-битной, а также от типа работающего сборщика мусора (рабочая станция или серверный сборщик мусора). В следующей таблице показаны размеры эфемерного сегмента по умолчанию.

Эфемерный сегмент может включать объекты поколения 2.Объекты поколения 2 могут использовать несколько сегментов (столько, сколько требуется вашему процессу и позволяет память).

Объем памяти, освобожденной от эфемерной сборки мусора, ограничен размером эфемерного сегмента. Объем освобожденной памяти пропорционален пространству, которое было занято мертвыми объектами.

Что происходит во время сборки мусора

Сборка мусора состоит из следующих этапов:

• Фаза маркировки, на которой выполняется поиск и создание списка всех живых объектов.

• Фаза перемещения, которая обновляет ссылки на объекты, которые будут уплотнены.

• Фаза уплотнения, которая восстанавливает пространство, занимаемое мертвыми объектами, и уплотняет уцелевшие объекты. На этапе сжатия объекты, пережившие сборку мусора, перемещаются к более старому концу сегмента.

  Поскольку коллекции поколения 2 могут занимать несколько сегментов, объекты, которые продвигаются в поколение 2, могут быть перемещены в более старый сегмент.Выжившие поколения 1 и 2 могут быть перемещены в другой сегмент, поскольку они повышены до поколения 2.

  Обычно куча больших объектов (LOH) не сжимается, поскольку копирование больших объектов снижает производительность. Однако в .NET Core и .NET Framework 4.5.1 и более поздних версиях вы можете использовать свойство GCSettings.LargeObjectHeapCompactionMode для сжатия кучи больших объектов по запросу. Кроме того, LOH автоматически уплотняется, когда устанавливается жесткий предел, если указать:

Сборщик мусора использует следующую информацию, чтобы определить, являются ли объекты активными:

• Корни стека .Переменные стека, предоставляемые JIT-компилятором и обходчиком стека. Оптимизация JIT может удлинять или сокращать области кода, в которых переменные стека передаются сборщику мусора.

• Дескрипторы сборки мусора . Дескрипторы, которые указывают на управляемые объекты и могут быть выделены пользовательским кодом или средой CLR.

• Статические данные . Статические объекты в доменах приложений, которые могут ссылаться на другие объекты.Каждый домен приложения отслеживает свои статические объекты.

Перед началом сборки мусора все управляемые потоки приостанавливаются, за исключением потока, запустившего сборку мусора.

На следующем рисунке показан поток, который запускает сборку мусора и вызывает приостановку других потоков.

Неуправляемые ресурсы

Для большинства объектов, создаваемых вашим приложением, вы можете полагаться на сборку мусора для автоматического выполнения необходимых задач по управлению памятью.Однако неуправляемые ресурсы требуют явной очистки. Наиболее распространенный тип неуправляемого ресурса — это объект, который является оболочкой для ресурса операционной системы, такого как дескриптор файла, дескриптор окна или сетевое соединение. Хотя сборщик мусора может отслеживать время жизни управляемого объекта, который инкапсулирует неуправляемый ресурс, у него нет конкретных знаний о том, как очистить ресурс.

При создании объекта, который инкапсулирует неуправляемый ресурс, рекомендуется предоставить необходимый код для очистки неуправляемого ресурса в общедоступном методе Dispose .Предоставляя метод Dispose , вы позволяете пользователям вашего объекта явно освобождать его память, когда они закончат работу с объектом. При использовании объекта, который инкапсулирует неуправляемый ресурс, обязательно вызовите Dispose по мере необходимости.

Вы также должны предоставить способ освобождения ваших неуправляемых ресурсов на случай, если потребитель вашего типа забудет позвонить Dispose . Вы можете использовать безопасный дескриптор для упаковки неуправляемого ресурса или переопределить объект.Finalize () метод.

Дополнительные сведения об очистке неуправляемых ресурсов см. В разделе Очистка неуправляемых ресурсов.

См. Также

Повысьте производительность приложений с помощью этих передовых методов ГХ

Производительность приложений находится в центре нашего внимания, и оптимизация сборки мусора — хорошее место для небольших, но значимых улучшений

Автоматическая сборка мусора (вместе с JIT HotSpot Compiler) является одним из наиболее продвинутых и наиболее ценных компонентов JVM, но многие разработчики и инженеры гораздо менее знакомы с Garbage Collection (GC), как она работает и как она влияет на приложение. представление.

Во-первых, для чего вообще нужен GC? Сборка мусора — это процесс управления памятью для объектов в куче. По мере того, как объекты выделяются в куче, они проходят несколько этапов сбора — обычно довольно быстро, поскольку у большинства объектов в куче короткий срок жизни.

События сборки мусора состоят из трех этапов — маркировки, удаления и копирования / уплотнения. На первом этапе сборщик мусора просматривает кучу и помечает все как живые (ссылочные) объекты, объекты, на которые нет ссылок, или как доступное пространство памяти.Затем объекты, на которые нет ссылок, удаляются, а оставшиеся объекты уплотняются. В поколенческих сборках мусора объекты «стареют» и продвигаются через 3 пространства в своей жизни — Эдем, пространство выжившего и пространство владения (старое). Это смещение также происходит как часть фазы уплотнения.

Но хватит об этом, перейдем к самому интересному!

Psst! Ищете решение для повышения производительности приложений? OverOps помогает компаниям определять не только время и место замедления, но и то, почему и как они возникают.Посмотрите живую демонстрацию, чтобы увидеть, как это работает.

Знакомство со сборкой мусора (GC) в Java

Одна из замечательных особенностей автоматизированного сборщика мусора заключается в том, что разработчикам на самом деле не требуется , чтобы понять, как он работает. К сожалению, это означает, что многие разработчики НЕ понимают, как это работает. Понимание сборки мусора и множества доступных сборщиков мусора в чем-то похоже на знание команд Linux CLI. Технически вам не нужно их использовать, но знание и удобство их использования может существенно повлиять на вашу продуктивность.

Так же, как и с командами CLI, здесь есть абсолютные основы. ls команда для просмотра списка папок в родительской папке, mv для перемещения файла из одного места в другое и т. Д. В GC такие команды будут эквивалентны знанию того, что существует более одного GC для выбрать из, и этот сборщик мусора может вызвать проблемы с производительностью. Конечно, есть еще много чего узнать (об использовании Linux CLI И о сборке мусора).

Цель изучения процесса сборки мусора в Java — не только для беспричинных (и утомительных) разговоров, но и в том, чтобы научиться эффективно внедрять и поддерживать правильный сборщик мусора с оптимальной производительностью для вашей конкретной среды.Знать, что сборка мусора влияет на производительность приложения, является основным, и существует множество передовых методов для повышения производительности сборки мусора и уменьшения его влияния на надежность приложения.

Проблемы производительности GC

1. Утечки памяти —

Зная структуру кучи и то, как выполняется сборка мусора, мы знаем, что использование памяти постепенно увеличивается до тех пор, пока не произойдет событие сборки мусора и использование не снизится. Использование кучи для объектов, на которые имеются ссылки, обычно остается стабильным, поэтому уменьшение должно происходить до более или менее того же объема.

При утечке памяти каждое событие GC очищает меньшую часть объектов кучи (хотя многие оставленные объекты не используются), поэтому использование кучи будет продолжать увеличиваться до тех пор, пока память кучи не будет заполнена и не возникнет исключение OutOfMemoryError. Причина в том, что сборщик мусора помечает для удаления только те объекты, на которые нет ссылок. Таким образом, даже если объект, на который имеется ссылка, больше не используется, он не будет удален из кучи. Есть несколько полезных приемов программирования для предотвращения этого, о которых мы поговорим чуть позже.

2. Непрерывные мероприятия «Останови мир» —

В некоторых сценариях сборку мусора можно назвать событием Stop the World, потому что, когда оно происходит, все потоки в JVM (и, следовательно, приложение, работающее на нем) останавливаются, чтобы разрешить выполнение GC. В исправных приложениях время выполнения GC относительно невелико и не оказывает большого влияния на производительность приложения.

Однако в неоптимальных ситуациях события Stop the World могут сильно повлиять на производительность и надежность приложения.Если событие GC требует паузы Stop the World и занимает 2 секунды для выполнения, конечный пользователь этого приложения будет испытывать 2-секундную задержку, поскольку потоки, выполняющие приложение, останавливаются, чтобы разрешить GC.

Когда происходят утечки памяти, непрерывные события Stop the World также являются проблематичными. Поскольку при каждом выполнении сборщика мусора очищается меньше памяти кучи, для заполнения оставшейся памяти требуется меньше времени. Когда память заполнена, JVM запускает другое событие GC. В конце концов, JVM будет запускать повторяющиеся события Stop the World, вызывающие серьезные проблемы с производительностью.

3. Использование ЦП —

И все сводится к загрузке процессора. Основным признаком непрерывных событий GC / Stop the World является скачок загрузки ЦП. Сборщик мусора — это сложная с вычислительной точки зрения операция, поэтому на него может потребоваться больше, чем справедливая доля мощности процессора. Для сборщиков мусора, которые запускают параллельные потоки, загрузка ЦП может быть еще выше. Выбор правильного GC для вашего приложения будет иметь наибольшее влияние на использование ЦП, но есть и другие способы оптимизации для повышения производительности в этой области.

Из этих проблем производительности, связанных со сборкой мусора, мы можем понять, что, какими бы продвинутыми GC ни были (и они становятся довольно продвинутыми), их ахиллесова пята остается прежней.Избыточное и непредсказуемое размещение объектов. Чтобы повысить производительность приложения, недостаточно выбрать правильный сборщик мусора. Нам нужно знать, как работает этот процесс, и нам нужно оптимизировать наш код, чтобы наши сборщики мусора не потребляли чрезмерные ресурсы и не вызывали чрезмерных пауз в нашем приложении.

GC поколения

Прежде чем мы углубимся в различные Java GC и их влияние на производительность, важно понять основы генеральной сборки мусора. Основная концепция сборки мусора поколений основана на идее, что чем дольше существует ссылка на объект в куче, тем менее вероятно, что он будет помечен для удаления.Пометив объекты образным «возрастом», они могут быть разделены на разные области хранения, чтобы сборщик мусора помеивал их реже.

Когда объект размещается в куче, он помещается в так называемое пространство Эдема. Именно здесь объекты начинаются и в большинстве случаев именно здесь они помечаются для удаления. Объекты, которые выживают на этой стадии, «празднуют день рождения» и копируются в пространство Survivor. Этот процесс показан ниже: