Rdd process linux что это
Оригинал: All You Need To Know About Processes in Linux [Comprehensive Guide]
Автор: Aaron Kili
Дата публикации: 31 марта 2017 года
Перевод: А. Кривошей
Дата перевода: август 2017 г.
В этой статье мы дадим базовое понимание процессов и кратко рассмотрим управление процессами в Linux с помощью специальных команд.
Процесс относится к выполнению программы - он представляет собой запущенный экземпляр программы, составленный из инструкций, данных, считанных из файлов, других программ, или полученных от пользователя.
Типы процессов
В Linux есть два основных типа процессов:
Процессы переднего плана (также известны как интерактивные процессы) - они инициализируются и контролируются в терминальной сессии. Другими словами, для запуска таких процессов в системе должен находиться пользователь, они не запускаются автоматически как часть системных служб.
Фоновые процессы (также известны как неинтерактивные/автоматические процессы) - не подключены к терминалу. Они не ждут ввода от пользователя.
Что такое демоны
Это специальные типы фоновых процессов, которые запускаются при загрузке системы и остаются запущенными в виде служб, они не завершаются. Демоны запускаются как системные задачи, спонтанно. Тем не менее, пользователь может контролировать их через процесс init.
Создание процессов в Linux
Обычно новый процесс создается уже существующим процессом, который делает в памяти свою точную копию. Дочерний процесс получает то же окружение, что и его родительский процесс, отличается только номер ID.
Есть два распространенных способа создания нового процесса в Linux:
1. С помощью функции System(). Этот способ сравнительно прост, однако неэффективен и создает определенные риски с точки зрения безопасности.
2. С помощью функций fork() и exec() - более продвинутая техника с точки зрения гибкости, скорости и безопасности.
Как Linux идентифицирует процессы?
Поскольку Linux - многопользовательская система, и различные пользователи могут одновременно запускать разные программы, каждый запущенный экземпляр программы должен получать уникальный идентификатор от ядра системы.
Программы идентифицируются по ID процесса (PID), а также по ID родительского процесса (PPID), поэтому процессы можно разделить на следующие категории:
Родительские процессы - это процессы, которые в процессе работы создают другие процессы.
Дочерние процессы - это процессы, созданные другими процессами.
Процесс Init
Процесс Init - это родительский процесс для всех процессов в системе, это первая программа, которая исполняется при загрузке системы Linux; он управляет всеми другими процессами в системе. Init запускается непосредственно ядром системы, поэтому он в принципе не имеет родительского процесса.
Процесс Init всегда получает ID 1. Он функционирует как приемный родитель для всех осиротевших процессов.
Для определения ID процесса можно использовать команду pidof:
Найти ID процесса и ID родительского процесса для системной оболочки можно с помощью команд:
Запуск процессов в Linux
При старте команды или программы (например cloudcmd – CloudCommander), она запускает процесс в системе. Вы можете запустить процесс переднего плана (интерактивный), как показано ниже, он подключится к терминалу и пользователь сможет взаимодействовать с ним:
Фоновые процессы в Linux
Для запуска фонового процесса (неинтерактивного) используется символ &, при этом процесс не сможет читать ввод от пользователя, пока не будет перемещен на передний план.
Для продолжения выполнения приостановленного в фоне процесса, используется команда bg:
Для перевода процесса из фонового режима на передний план используется команда fg вместе с ID:
Состояние процесса в Linux
В зависимости от различных обстоятельств состояние процесса во время работы может меняться. В Linux процесс может находиться в следующих состояниях:
Running (работа) - процесс работает (он является текущим процессом в системе) или готов к работе (ждет выделения ресурсов процессора).
Waiting (ожидание) - в этом состоянии процесс ждет события, которое должно запустить его, или выделения системных ресурсов.
Кроме того, ядро системы делит процессы в состоянии ожидания на два типа: перываемые процессы, состояние ожидания которых может быть прервано сигналом, и непрерываемые, состояние ожидания которых может быть прервано только аппаратным способом.
Stopped (остановка) - в этом состоянии процесс останавливает работу, обычно после получения соответствующего сигнала. Например, процесс может быть остановлен для отладки.
Zombie (зомби) - процесс мертв, то есть он был остановлен, но в системе осталась выполняемая им задача.
Как просмотреть активные процессы в Linux
В Linux есть несколько утилит для просмотра запущенных в системе процессов, наиболее широко известны команды ps и top:
1. Команда ps
Она выводит информацию о выбранных активных процессах, как показано ниже.
2. top – утилита системного мониторинга
top - это мощная утилита, которая позволяет в режиме реального времени просматривать список запущенных процессов, как показано ниже:
3. glances – утилита системного мониторинга
glances - это сравнительно новая утилита для мониторинга активности системы с продвинутыми возможностями:
Есть также еще несколько полезных программ, которые вы можете использовать для просмотра списка активных процессов, почитать о них можно по ссылкам ниже.
Управление процессами в Linux
В Linux также имеются команды для управления процессами, например kill, pkill, pgrep и killall. Ниже приведено несколько примеров их использования:
Если вы хотите подробно изучить использование этих команд, информация по ссылкам ниже.
Обратите внимание, что с их помощью вы можете завршать зависшие приложения, которые тормозят вашу систему.
Отправка сигналов процессу
Фундаментальный способ управления процессами в Linux - это отправка им сигналов, которых имеется достаточно много. Посмотреть список всех сигналов можно с помощью команды:
Для отправки сигналов процессу используются описанные выше команды kill, pkill или pgrep. Однако программа ответит на сигнал, только если она запрограммирована распознавать такой сигнал.
Большинство сигналов предназначены для использования системой или программистами при написании кода. Следующие сигналы могут быть полезны пользователю:
SIGHUP 1 – отправляется процессу при закрытии контролирующего его терминала.
SIGINT 2 – отправляется процессу контролирующим его терминалом, если пользователь прерывает работу процесса клавишами [Ctrl+C].
SIGQUIT 3 – отправляется процессу, если пользователь посылает сигнал выхода из программы [Ctrl+D].
SIGKILL 9 – этот сигнал немедленно завершает (убивает) процесс без выполнения любых операций очистки файлов, логов и т.д.
SIGTERM 15 – это сигнал завершения работы программы (он по умоланию отправляется командой kill).
SIGTSTP 20 – отправляется процессу контролирующим его терминалом с запросом на остановку (terminal stop); инициируется при нажатии [Ctrl+Z].
Ниже приведены примеры использования команд kill для завершения работы Firefox при его зависании с использованием PID:
Для завершения программы с использованием ее названия используются команды pkill или killall:
Изменение приоритета процесса
В Linux все активные процессы имеют определенное значение приоритета (nice). Процессы с более высоким приоритетом обычно получают больше процессорного времени, чем процессы с более низким приоритетом.
Однако пользователь с привилегиями root может менять приоритет с помощью команд nice и renice.
В выводе команды top столбец NI отображает значения nice для процессов.
Вы можете использовать команду nice, чтобы задать значение nice процесса. Не забывайте, что обычный пользователь может присвоить процессу значение nice от 0 до 20, только если это процесс ему принадлежит.
Отрицательные значения nice может использовать только пользователь root.
Для понижения приоритета процесса используется команда renice:
Другие статьи об управлении процессами в Linux вы найдете на странице "Процессы в Linux-системе".
Я не совсем понимаю что это значит. Это как данные (секционированные объекты), хранящиеся на жестком диске, если да, то почему RDD могут иметь пользовательские классы (такие как java, scala или python)
пользователи создают RDDs двумя способами: путем загрузки внешнего набора данных или распределение коллекции объектов (например, списка или набора) в их программа драйвера
Я действительно смущен пониманием RDD в целом и в отношении spark и hadoop.
может кто-нибудь помочь.
RDD-это, по сути, искровое представление набора данных, распределенных по нескольким машинам, с API, позволяющими вам действовать на нем. RDD может поступать из любого источника данных, например текстовых файлов, базы данных через JDBC и т. д.
РДУ отказоустойчивые параллельные структуры данных, которые позволяют пользователям явно сохраняйте промежуточные результаты в памяти, контролируйте их секционирование для оптимизации размещения данных и управление ими с помощью богатый набор операторов.
Если вы хотите получить полную информацию о том, что такое RDD, прочитайте одну из основных научных работ Spark,устойчивые распределенные наборы данных: отказоустойчивая абстракция для кластерных вычислений в памяти
RDD является логической ссылкой на dataset , который разделен на множество компьютеров-серверов в кластере. RDDs неизменяемы и самостоятельно восстанавливаются в случае сбоя.
dataset могут быть данные, загруженные извне пользователем. Это может быть файл json, csv-файл или текстовый файл без определенной структуры данных.
обновление: здесь статья описание внутренних органов RDD:
надеюсь, что это помогает.
формально RDD представляет собой секционированную коллекцию записей только для чтения. RDDs может быть создан только с помощью детерминированных операций либо (1) данных в стабильном хранилище, либо (2) других RDDs.
RDDs имеют следующие свойства -
неизменяемость и разделение: RDDs состоит из коллекции записей, которые секционированы. Раздел является базовой единицей параллелизма в RDD, и каждый раздел является одним логическим разделением данных, которое является неизменяемым и создается с помощью некоторых преобразований на существующих разделах.Неизменность помогает достичь согласованности в вычислениях.
пользователи могут определить свои собственные критерии для секционирования на основе ключей, на которых они хотят объединить несколько наборов данных, если это необходимо.
крупнозернистые операции: Крупнозернистый операции-это операции, которые применяются ко всем элементам в наборах данных. Например-карта, или фильтр, или операция groupBy, которая будет выполняться на всех элементах в разделе RDD.
Отказоустойчивость: Поскольку RDDs создаются по набору преобразований, он регистрирует эти преобразования, а не фактические данные.График этих преобразований для получения одного RDD называется графом Lineage.
в случае, если мы потеряем некоторый раздел RDD, мы можем воспроизвести преобразование на этом разделе в lineage выполните одно и то же вычисление, а не репликацию данных на нескольких узлах.Эта характеристика самое большое преимущество RDD, потому что она сохраняет много усилия в управлении данными и репликации и таким образом достигает более быстрых вычислений.
ленивых вычислений: Spark вычисляет RDDs лениво в первый раз, когда они используются в действии, чтобы он мог передавать преобразования. Таким образом, в приведенном выше примере RDD будет оцениваться только при действии count() вызванный.
настойчивость: Пользователи могут указать, какие RDDs они будут повторно использовать, и выбрать для них стратегию хранения (например, в памяти или на диске и т. д.)
Процессы - это по сути работающие программы, которые могут быть запущены как самой системой, так и любым пользователем. Данные программы могут работать как в фоновом режиме и быть невидимыми, так и на переднем плане и иметь своеобразный видимый интерфейс. Для выполнения каждого процесса приходится выделять память и процессорное время.
Для чего необходимо изучать процессы?
Бывает так, что компьютер “тормозит” и не позволяет выполнять некоторые важные операции. Такое происходит, когда какой-нибудь процесс занимает большую часть оперативной памяти или процессорного времени. Зная основы работы с процессами можно отключить мешающий процесс и разгрузить компьютер. Существуют ситуации, когда запущенная программа перестает реагировать на действия пользователя и никак не удается ее закрыть штатным способом. В данном случае достаточно найти процесс данной программы и принудительно закрыть программу.
К процессам часто обращаются, когда компьютер содержит вирус или другое вредоносное ПО. Взглянув на процессы можно найти аномальное поведение системы и найти вредоносное ПО. Поэтому даже обычному пользователю необходимо знать основы работы с процессами. Прежде, чем мы рассмотрим как управлять процессами, перечислим основные параметры, характерные для каждого процесса:
PID - (process ID) идентификатор каждого процесса
PPID - (parent process ID) идентификатор родительского процесса. Процесс может порождать и другие процессы.
UID, GID - реальные идентификаторы пользователя и его группы, запустившего данный процесс.
EUID, EGID - эффективные идентификаторы пользователя и его группы. В 16-ом уроке мы изучали признаки доступа SUID, SGID. Когда пользователь запускает файл с установленными признаками, то эффективные идентификаторы (EUID, EGID) равны реальным идентификаторам (UID, GID) владельца данного файла. То есть система смотрит на эффективные идентификаторы и таким образом узнает, что был установлен признак SUID/SGID и предоставляет доступ пользователю. Если пользователь запустит любой другой файл без установленного признака SUID/SGID, то реальные и эффективные идентификаторы всегда равны.
Priority/Nice - приоритет и относительный приоритет. Служит для выделения большего или меньшего процессорного времени для определенного процесса. Разрешается менять только относительный приоритет (Nice). Его значение варьируется от -20 до +19. Чем ниже значение относительного приоритета, тем больше процессорного времени выделяется для данного процесса.
В практических приложениях существует много итерационных алгоритмов (таких как машинное обучение, алгоритмы графов и т. Д.) И интерактивных инструментов для извлечения данных.Сходство этих сценариев применения заключается в том, что между различными этапами расчета Повторное использование промежуточных результатов То есть выход одного этапа будет использоваться как вход следующего этапа. Тем не менее, текущийКаркас MapReduce записывает промежуточные результаты в HDFS, Приносит много репликации данных, дискового ввода-вывода и сериализации накладных расходов. Хотя платформы графовых вычислений, такие как Pregel, также хранят результаты в памяти, эти платформы могут поддерживать только некоторые конкретные вычислительные режимы и не обеспечивают общую абстракцию данных. RDD появился, чтобы удовлетворить эту потребность, он предоставляет абстрактную архитектуру данных, нам не нужно беспокоиться о распределенных характеристиках базовых данных, просто выражаем логику конкретного приложения в виде последовательности обработки преобразования,Операции преобразования между различными RDD образуют зависимости, Может быть конвейерным, тем самым избегая хранения промежуточных результатов, значительно сокращая репликацию данных, дисковый ввод-вывод и издержки сериализации.
- RDD читает во внешнем источнике данных (или коллекции в памяти) для создания;
- СДР подвергается серии операций «преобразования», каждый раз, когда для следующего использования «преобразования» будет создаваться другой СДР;
- Последний СДР обрабатывается операцией «действие» и выводится во внешний источник данных (или становится коллекцией Scala или скаляром).
- Создайте контекст выполнения этой программы Spark, то есть создайте объект SparkContext;
- Чтение данных из внешнего источника данных (например, файла HDFS) для создания объекта fileRDD;
- Создайте отношение зависимостей между fileRDD и filterRDD для формирования графа DAG. В настоящее время никаких реальных вычислений не происходит, просто запишите траекторию конверсии;
- Когда выполняется 6-я строка кода, count () является операцией типа действия, запускающей реальные вычисления, начинающей фактически выполнять операцию преобразования из fileRDD в filterRDD и сохраняющей результат в памяти, и, наконец, вычисляющей filterRDD содержит Количество элементов.
В целом, основные причины, по которым Spark может добиться эффективных вычислений после внедрения RDD, заключаются в следующем:
（1）Эффективная отказоустойчивость, Существующая распределенная общая память, хранилище значений ключей, базы данных в памяти и т. Д. Для обеспечения отказоустойчивости необходимо выполнять репликацию данных или ведение журналов между узлами кластера, то есть между узлами будет происходить большой объем передачи данных, который требует больших объемов данных. Для крупномасштабных приложений это принесет большие накладные расходы. В проекте RDD данные доступны только для чтения и не могут быть изменены. Если вам нужно изменить данные, вы должныКонвертировать родительский RDD в дочерний RDD，Это установило кровные отношения между различными СДР, Поэтому СДР представляет собой особый набор, который по своей природе устойчив к отказам и не требует избыточности данных (например, контрольных точек) для достижения отказоустойчивости.Необходимо только пересчитать потерянный раздел с помощью RDD-зависимости между родителями и детьми (кровные отношения), чтобы добиться отказоустойчивости.Нет необходимости откатывать всю систему, что позволяет избежать высокой стоимости репликации данных, и процесс пересчета может выполняться параллельно между различными узлами, обеспечивая эффективную отказоустойчивость. Кроме того, все операции преобразования, предоставляемые RDD, являются грубыми операциями (такими как отображение, фильтрация и объединение) .Зависимости RDD нужны только для записи таких операций грубого преобразования и не требуют записи определенных данных и различных мелких операций. Журнал (например, какой элемент данных был изменен), который значительно снижает отказоустойчивые накладные расходы в приложениях с интенсивным использованием данных;
（2）Промежуточные результаты сохраняются в памяти, Данные передаются между несколькими операциями RDD в памяти без «посадки» на диск, избегая ненужных затрат на чтение и запись на диск;
（3）Сохраненные данные могут быть объектами JavaИзбегайте ненужных накладных расходов на сериализацию и десериализацию объектов.
Различные операции в RDD приведут к тому, что разделы в разных RDD будут иметь разные зависимости. Зависимости в СДР делятся на Узкая зависимость (Узкая зависимость) и Широкая зависимость (Широкая зависимость), на рисунке 3 показана разница между двумя зависимостями.
Узкая зависимость показывает, что раздел родительской СДР соответствует разделу дочерней СДР, или раздел нескольких родительских СДР соответствует разделу дочерней СДР;Например, на рисунке 3 (a) RDD1 является родительским RDD RDD2, RDD2 является дочерним RDD, раздел 1 RDD1 соответствует разделу RDD2 (то есть разделу 4), для другого примера RDD6 и RDD7 оба являются родительским RDD RDD8, Раздел в RDD6 (раздел 15) и раздел в RDD7 (раздел 18) соответствуют разделу в RDD8 (раздел 21).
Широкая зависимость проявляется в существовании одного раздела родительского RDD, соответствующего нескольким разделам дочернего RDD.Например, на рисунке 3 (b) RDD9 является родительским RDD RDD12, а раздел 24 в RDD9 соответствует двум разделам в RDD12 (то есть разделу 27 и разделу 28).
Вообще говоря, если раздел родительского RDD используется только разделом дочернего RDD, это узкая зависимость, в противном случае это широкая зависимость. Типичные операции с узкими зависимостями включают map, filter и union. Типичные операции с широкими зависимостями включают groupByKey и sortByKey. Для операций соединения есть два случая.
(1) Совместное разделение входных данных относится к узкой зависимости (как показано в (a)). Так называемое разделение (разделение на части) относится ко всем «ключам» раздела нескольких родительских RDD, которые попадают в один и тот же раздел дочернего RDD, и не создает раздел одного и того же родительского RDD. В случае двух разделов ребенка RDD.
(2) Некооперативное разделение входных данных относится к широкой зависимости, как показано в (b).
Для узко зависимых СДР все родительские разделы могут быть рассчитаны конвейерным способом, не вызывая смешения данных между сетями. Для СДР с широкой зависимостью это обычно сопровождается операцией Shuffle, то есть сначала необходимо вычислить все данные родительского раздела, а затем между узлами выполняется Shuffle.
Рисунок 3 Разница между узкой и широкой зависимостями
Этот дизайн зависимостей Spark делает его по своей природе отказоустойчивым и значительно увеличивает скорость выполнения Spark. Потому что набор данных RDD запоминает, как он эволюционировал из других RDD через «кровные отношения». Кровные отношения записывают поведение операции грубого преобразования. Когда часть данных раздела RDD потеряна, он может пройти Отношения крови получают достаточно информации для пересчета и восстановления потерянного раздела данных, что повышает производительность. Условно говоря, в двух типах зависимостей восстановление после сбоя в узкой зависимости более эффективно: нужно только пересчитать потерянный раздел на основе родительского раздела RDD (не нужно пересчитывать все разделы), и оно может находиться в разных узлах параллельно. Пересчитать. Для широких зависимостей сбой одного узла обычно означает, что процесс пересчета будет включать несколько родительских разделов RDD, что является дорогостоящим. Кроме того, Spark также предоставляет контрольные точки данных и ведение журнала для сохранения промежуточных RDD, поэтому вам не нужно возвращаться к начальному этапу при выполнении восстановления после сбоя. Во время восстановления после сбоя Spark сравнивает стоимость контрольных точек данных и стоимость пересчета разделов RDD для автоматического выбора оптимальной стратегии восстановления.
Посредством вышеприведенного введения в концепции RDD, зависимостей и разделений этапов, в сочетании с базовым процессом работы Spark, представленным ранее, приведено краткое описание процесса работы RDD в архитектуре Spark (как показано на рисунке 9-12):
(1) создать объект RDD;
(2) SparkContext отвечает за расчет зависимостей между RDD и построением DAG;
(3) DAGScheduler отвечает за декомпозицию графа DAG на несколько этапов, каждый этап содержит несколько задач, и каждая задача будет распределена планировщиком задач для каждого рабочего узла (рабочего узла) ) На Исполнителя выполнить.
СДР можно создать двумя способами:
* Первый тип: чтение внешнего набора данных. Например, загрузить наборы данных из локальных файлов или загрузить наборы данных из внешних источников данных, таких как файловая система HDFS, HBase, Cassandra, Amazon S3 и т. Д. Spark может поддерживать текстовые файлы, файлы SequenceFile (SequenceFile, предоставляемый Hadoop - это текстовый файл хранения, состоящий из двоичного сериализованного потока байтов ключа / значения) и другие файлы, которые соответствуют формату Hadoop InputFormat.
* Второй вид: вызов метода параллелизации SparkContext и его создание в существующей коллекции (массиве) в Driver.
Создать RDD, загрузив данные из файловой системы
Создавать RDD из параллельных коллекций (массивов)
Вы можете вызвать метод параллелизации SparkContext, чтобы создать существующую коллекцию (массив) в Driver.
Пожалуйста, работайте в pyspark ниже:
Используйте список выше, чтобы создать. В Python нет базового типа данных для массивов. Для простоты понимания вы можете использовать списки в качестве массивов на других языках.
После создания СДР во время последующего использования обычно выполняются две операции:
* Перерабатывать (Преобразование): создание нового набора данных на основе существующего набора данных.
* действие (Действие): выполнить операцию с набором данных и вернуть рассчитанное значение.
Операция преобразования
Для СДР каждая операция преобразования будет создавать другой СДР для следующего «преобразования». Преобразованный СДР оценивается лениво, то есть весь процесс преобразования записывает только траекторию преобразования, и никаких реальных вычислений не происходит. Только когда он сталкивается с операциями действия, будут выполняться реальные вычисления, начиная с отношения крови Начиная с источника, выполните физические операции преобразования.
Вот некоторые распространенные операции преобразования (API преобразования):
* filter (func): отфильтровать элементы, которые удовлетворяют функции func, и вернуть новый набор данных
* map (func): передать каждый элемент в функцию func и вернуть результат в виде нового набора данных
* flatMap (func): аналогично map (), но каждый входной элемент может быть сопоставлен с 0 или более выходными результатами
* groupByKey (): при применении к набору данных (K, V) пар ключ-значение возвращается новый (K, Iterable) набор данных
* reduceByKey (func): при применении к набору данных из (K, V) пар ключ-значение возвращается новая (K, V) форма набора данных, каждая из которых имеет значения Передать каждый ключ функции func для агрегации
Процесс — это экземпляр запущенной программы. Всякий раз, когда в терминале выполняется какая-нибудь команда (например, команда pwd ), система создает/запускает новый процесс.
Типы процессов
В Linux существует три основных типа процессов:
Как Linux идентифицирует процессы?
Поскольку Linux является многопользовательской системой, разные пользователи могут запускать различные программы, при этом каждый запущенный экземпляр программы должен быть однозначно идентифицирован ядром.
Родительские процессы — это процессы, которые во время своего выполнения создают другие процессы.
Дочерние процессы — эти процессы, создаваемые другими процессами во время своего выполнения.
Примечание: В любой момент времени в системе не существует двух процессов с одинаковым PID. Вновь создаваемому процессу может быть назначен ранее использованный свободный PID.
Состояния процесса в Linux
Рассмотрим основные состояния процесса:
Выполнение — процесс либо запущен (текущий процесс в системе), либо готов к запуску (ожидает передачи на выполнение процессору).
Ожидание — процесс ожидает наступления некоторого события (пользовательского ввода, сигнала от другого процесса и т.п.) или выделения системных ресурсов. Кроме того, ядро также различает два типа ожидающих процессов:
прерываемые ожидающие процессы — могут быть прерваны сигналами;
непрерываемые ожидающие процессы — процессы ожидают непосредственно на аппаратном уровне и не могут быть прерваны каким-либо событием/сигналом.
Завершен — процесс был остановлен, как правило, путем получения сигнала штатного завершения работы exit().
Как получить идентификатор (PID) процесса
Для отображения идентификатора нужного вам процесса можно использовать команду pidof, например:
$ pidof init
$ pidof bash
$ pidof systemd
Примечание: На вышеприведенном скриншоте вы можете видеть, что процессу init назначен PID=1 , а процессу systemd — PID=881 , хотя системой инициализации в Debian является именно systemd. Детально о том, почему возникла такая путаница, читайте здесь.
Чтобы вывести PID и PPID текущей оболочки, выполните:
$ echo $$
$ echo $PPID
Запуск интерактивного процесса в Linux
Как только вы выполните какую-нибудь команду или программу (например, firefox ), она создаст в системе соответствующий процесс. Вы можете запустить процесс переднего плана (он будет подключен к терминалу, ожидая пользовательского ввода) следующим образом:
Запуск фонового процесса в Linux
Запуск процесса в фоновом режиме полезен только для программ, которые не нуждаются в пользовательском вводе (через оболочку). Перевод задания в фоновый режим обычно выполняется, когда ожидается, что выполнение задания займет много времени.
Кроме этого, в оболочку встроена утилита управления заданиями jobs, которая позволяет легко управлять несколькими процессами, переключая их между передним планом и фоновым исполнением. Также, с помощью jobs процессы могут быть сразу запущены в фоновом режиме.
Чтобы запустить процесс в фоновом режиме, используйте символ & после имени запускаемой программы. В этом случае процесс не будет принимать пользовательский ввод, пока не переместится на передний план:
Отслеживание активных процессов
Существует несколько различных инструментов для просмотра/перечисления запущенных в системе процессов. Двумя традиционными и хорошо известными из них являются команды ps и top:
Команда ps
Отображает информацию об активных процессах в системе, как показано на следующем скриншоте:
Для получения дополнительной информации о процессах, запущенных текущим пользователем, применяется опция -f :
Столбцы, присутствующие в выводе команды ps , имеют следующие значения:
UID — идентификатор пользователя, которому принадлежит процесс (тот, от чьего имени происходит выполнение).
PID — идентификатор процесса.
PPID — идентификатор родительского процесса.
C — загрузка CPU процессом.
STIME — время начала выполнения процесса.
TTY — тип терминала, связанного с процессом.
TIME — количество процессорного времени, потраченного на выполнение процесса.
CMD — команда, запустившая этот процесс.
Также можно отобразить информацию по конкретному процессу, используя команду ps -f [PID] , например:
Есть и другие опции, которые можно использовать вместе с командой ps :
-a — показывает информацию о процессах по всем пользователям;
-x — показывает информацию о процессах без терминалов;
-u — показывает дополнительную информацию о процессе по заданному UID или имени пользователя;
-e — отображение расширенной информации.
Если вы хотите вывести вообще всю информацию по всем процессам системы, то используйте команду ps –aux :
Обратите внимание на выделенный заголовок. Команда ps поддерживает функцию сортировки процессов по соответствующим столбцам. Например, чтобы отсортировать список процессов по потреблению ресурсов процессора (в порядке возрастания), введите команду:
$ ps -aux --sort=%cpu
Если вы ходите выполнить сортировку по потреблению памяти (в порядке убывания), то добавьте к имени интересующего столбца знак минуса:
$ ps -aux --sort=-%mem
Еще один очень популярный пример использования команды ps — это объединение её и команды grep для поиска заданного процесса по его имени:
$ ps -aux | grep bash
Команда top
Команда top отображает информацию о запущенных процессах в режиме реального времени:
PID — идентификатор процесса.
USER — пользователь, которому принадлежит процесс.
PR — приоритет процесса на уровне ядра.
NI — приоритет выполнения процесса от -20 до 19 .
VIRT — общий объем (в килобайтах) виртуальной памяти (физическая память самого процесса; загруженные с диска файлы библиотек; память, совместно используемая с другими процессами и т.п.), используемой задачей в данный момент.
RES — текущий объем (в килобайтах) физической памяти процесса.
SHR — объем совместно используемой с другими процессами памяти.
%CPU — процент используемых ресурсов процессора.
%MEM — процент используемой памяти.
TIME+ — количество процессорного времени, потраченного на выполнение процесса.
COMMAND — имя процесса (команды).
< — процесс с высоким приоритетом;
N — процесс с низким приоритетом;
l — многопоточный процесс;
s — лидер сессии.
Примечание: Все процессы объединены в сессии. Процессы, принадлежащие к одной сессии, определяются общим идентификатором сессии — идентификатором процесса, который создал эту сессию. Лидер сессии — это процесс, идентификатор сессии которого совпадает с его идентификаторами процесса и группы процессов.
Команда glances
Команда glances — это относительно новый инструмент мониторинга системы с расширенными функциями:
Примечание: Если в вашей системе отсутствует данная утилита, то установить её можно с помощью следующих команд:
$ yum install -y glances
$ sudo apt-get update
$ sudo apt-get install glances
Управление процессами в Linux
Также в Linux присутствуют некоторые команды для управления процессами:
kill — посылает процессу сигнал завершения работы;
pkill — завершает процесс по его имени;
pgrep — ищет процесс по его имени (и, опционально, по имени запустившего его пользователя);
killall — завершает все активные процессы.
Ниже приведены несколько основных примеров их использования:
$ pgrep -u diego firefox
$ kill 6516
$ pgrep -u diego firefox
$ pgrep -u diego glances
$ pkill glances
$ pgrep -u diego glances
Отправка сигналов процессам
Основополагающим способом управления процессами в Linux является отправка им соответствующих сигналов. Для перечисления списка всех доступных сигналов, введите команду:
Большинство сигналов предназначены для внутреннего использования системой или для программистов, когда они пишут код. Ниже приведены наиболее полезные сигналы:
SIGHUP (1) — отправляется процессу, когда его управляющий терминал закрыт.
SIGINT (2) — отправляется процессу управляющим терминалом, когда пользователь прерывает процесс нажатием клавиш Ctrl+C.
SIGQUIT (3) — отправляется процессу, если пользователь посылает сигнал выхода Ctrl+D.
SIGKILL (9) — этот сигнал немедленно завершает (убивает) процесс, и процесс не будет выполнять никаких операций очистки за собой.
SIGTERM (15) — сигнал завершения программы (отправляется командой kill по умолчанию).
SIGTSTP (20) — отправляется процессу управляющим терминалом с запросом на остановку; инициируется пользователем нажатием клавиш Ctrl+Z.
Ниже приведены примеры команды kill для уничтожения приложения firefox с помощью PID, после его зависания:
$ kill -SIGKILL 2275
Чтобы убить приложение, используя его имя, применяются команды pkill или killall , например:
Изменение приоритета процесса
В системе Linux все активные процессы имеют определенный приоритет выполнения, задаваемый так называемым nice-значением. Процессы с более высоким приоритетом обычно получают больше процессорного времени, чем процессы с более низким приоритетом. Однако пользователь с root-правами может повлиять на это с помощью команд nice и renice.
Узнать значение приоритета команды можно по выводу команды top (столбец NI):
Используйте команду nice , чтобы задать NI-значение для запускаемого процесса. Имейте в виду, что обычные пользователи могут задавать данный параметр в диапазоне от 0 до 20 тем процессам, которыми они владеют. Только пользователь root может использовать отрицательные значения приоритета.
Чем больше nice-значение, тем меньшим приоритетом будет обладать процесс. Например, вы можете задать приоритет для запускаемого процесса следующим образом:
$ nice -n 10 firefox
Чтобы изменить приоритет уже запущенного процесса, используйте команду renice следующим образом:
$ renice +8 5547
$ renice +8 1151
На данный момент это всё! Если у вас есть какие-либо вопросы или дополнительные идеи, вы можете поделиться ими с нами с помощью комментариев.
Читайте также: