pid 0 что значит
Изучаем процессы в Linux. Управление процессами
Обновл. 12 Июл 2021 |
Процесс — это экземпляр запущенной программы. Всякий раз, когда в терминале выполняется какая-нибудь команда (например, команда pwd ), система создает/запускает новый процесс.
Типы процессов
В Linux существует три основных типа процессов:
Процессы переднего плана (или «интерактивные процессы») — они инициализируются и управляются с помощью терминального сеанса. Другими словами, необходимым условием для запуска таких процессов является наличие пользователя, подключенного к системе; они не запускаются автоматически как часть системных функций/служб. Когда команда/процесс выполняется на переднем плане, то они полностью занимают запустивший их терминал. Вы не сможете использовать другие команды, т.к. приглашение оболочки будет недоступно, пока данный процесс выполняется на переднем плане.
Фоновые процессы (или «автоматические процессы») — это процессы, не подключенные к терминалу; они не ожидают пользовательского ввода данных. Таким образом, другие процессы могут выполняться параллельно с процессом, запущенным в фоновом режиме, поскольку им не нужно ждать его завершения.
Демоны (англ. «daemons») — это особый тип фоновых процессов, которые запускаются при старте системы и продолжают работать в виде службы; они не умирают. Такие процессы запускаются как системные задачи (службы). Однако при этом они могут управляться пользователем через init-процесс (о котором мы поговорим чуть позже). Например, к демонам относится служба электронных сообщений sendmail и sshd — служба, принимающая от клиентов запросы на соединения по протоколу ssh. За исключением процесса init и некоторых других, процессы демонов обычно имеют окончание d в своем имени.
Как Linux идентифицирует процессы?
Поскольку Linux является многопользовательской системой, разные пользователи могут запускать различные программы, при этом каждый запущенный экземпляр программы должен быть однозначно идентифицирован ядром.
Процессы запущенной программы имеют уникальный пятизначный номер — PID (сокр. от «Process IDentificator» — «идентификатор процесса»), а также PPID (сокр. от «Parent Process IDentificator» — «идентификатор родительского процесса»). В связи с этим процессы дополнительно разделяют на две группы:
Родительские процессы — это процессы, которые во время своего выполнения создают другие процессы.
Дочерние процессы — эти процессы, создаваемые другими процессами во время своего выполнения.
Прародителем всех процессов в системе является процесс init (от англ. «initialization») — первая программа, которая выполняется при загрузке Linux и управляет всеми другими процессами в системе. init запускается самим ядром и всегда имеет PID = 1, поэтому у него в принципе нет родительского процесса.
Примечание: В любой момент времени в системе не существует двух процессов с одинаковым PID. Вновь создаваемому процессу может быть назначен ранее использованный свободный PID.
Состояния процесса в Linux
Когда процесс передает ядру запрос, который не может быть исполнен сразу же, то процесс «погружается в сон/ожидание» и «пробуждается», когда запрос может быть удовлетворен. В связи с этим, в зависимости от текущей ситуации, процесс, во время своего выполнения, может переходить из одного состояния в другое:
Рассмотрим основные состояния процесса:
Выполнение — процесс либо запущен (текущий процесс в системе), либо готов к запуску (ожидает передачи на выполнение процессору).
Ожидание — процесс ожидает наступления некоторого события (пользовательского ввода, сигнала от другого процесса и т.п.) или выделения системных ресурсов. Кроме того, ядро также различает два типа ожидающих процессов:
прерываемые ожидающие процессы — могут быть прерваны сигналами;
непрерываемые ожидающие процессы — процессы ожидают непосредственно на аппаратном уровне и не могут быть прерваны каким-либо событием/сигналом.
Завершен — процесс был остановлен, как правило, путем получения сигнала штатного завершения работы exit().
Зомби — иногда, когда родительский процесс убивается до завершения дочернего процесса, дочерние процессы становятся «осиротевшими», при этом в качестве нового родителя (с соответствующим изменением PPID) им назначается процесс init. Убитые процессы, но при этом все еще отображающиеся в таблице процессов, называются процессами зомби (они мертвы и не используются).
Как получить идентификатор (PID) процесса
Для отображения идентификатора нужного вам процесса можно использовать команду pidof, например:
$ pidof init
$ pidof bash
$ pidof systemd
Чтобы вывести PID и PPID текущей оболочки, выполните:
Запуск интерактивного процесса в Linux
Как только вы выполните какую-нибудь команду или программу (например, firefox ), она создаст в системе соответствующий процесс. Вы можете запустить процесс переднего плана (он будет подключен к терминалу, ожидая пользовательского ввода) следующим образом:
Запуск фонового процесса в Linux
Запуск процесса в фоновом режиме полезен только для программ, которые не нуждаются в пользовательском вводе (через оболочку). Перевод задания в фоновый режим обычно выполняется, когда ожидается, что выполнение задания займет много времени.
Кроме этого, в оболочку встроена утилита управления заданиями jobs, которая позволяет легко управлять несколькими процессами, переключая их между передним планом и фоновым исполнением. Также, с помощью jobs процессы могут быть сразу запущены в фоновом режиме.
Чтобы запустить процесс в фоновом режиме, используйте символ & после имени запускаемой программы. В этом случае процесс не будет принимать пользовательский ввод, пока не переместится на передний план:
$ firefox #После Enter нажмите Ctrl+Z
$ jobs
Чтобы продолжить выполнение вышеупомянутой приостановленной команды в фоновом режиме, используйте команду bg (от англ. «begin»):
Чтобы отправить фоновый процесс на передний план, используйте команду fg (от англ. «foreground») вместе с идентификатором задания следующим образом:
Отслеживание активных процессов
Существует несколько различных инструментов для просмотра/перечисления запущенных в системе процессов. Двумя традиционными и хорошо известными из них являются команды ps и top:
Команда ps
Отображает информацию об активных процессах в системе, как показано на следующем скриншоте:
UID — идентификатор пользователя, которому принадлежит процесс (тот, от чьего имени происходит выполнение).
PID — идентификатор процесса.
PPID — идентификатор родительского процесса.
C — загрузка CPU процессом.
STIME — время начала выполнения процесса.
TTY — тип терминала, связанного с процессом.
TIME — количество процессорного времени, потраченного на выполнение процесса.
CMD — команда, запустившая этот процесс.
Есть и другие опции, которые можно использовать вместе с командой ps :
-a — показывает информацию о процессах по всем пользователям;
-x — показывает информацию о процессах без терминалов;
-u — показывает дополнительную информацию о процессе по заданному UID или имени пользователя;
-e — отображение расширенной информации.
Если вы хотите вывести вообще всю информацию по всем процессам системы, то используйте команду ps –aux :
Обратите внимание на выделенный заголовок. Команда ps поддерживает функцию сортировки процессов по соответствующим столбцам. Например, чтобы отсортировать список процессов по потреблению ресурсов процессора (в порядке возрастания), введите команду:
Если вы ходите выполнить сортировку по потреблению памяти (в порядке убывания), то добавьте к имени интересующего столбца знак минуса:
Еще один очень популярный пример использования команды ps — это объединение её и команды grep для поиска заданного процесса по его имени:
Команда top
Команда top отображает информацию о запущенных процессах в режиме реального времени:
PID — идентификатор процесса.
USER — пользователь, которому принадлежит процесс.
PR — приоритет процесса на уровне ядра.
VIRT — общий объем (в килобайтах) виртуальной памяти (физическая память самого процесса; загруженные с диска файлы библиотек; память, совместно используемая с другими процессами и т.п.), используемой задачей в данный момент.
RES — текущий объем (в килобайтах) физической памяти процесса.
SHR — объем совместно используемой с другими процессами памяти.
S (сокр. от «STATUS») — состояние процесса:
S (сокр. от «Sleeping») — прерываемое ожидание. Процесс ждет наступления события.
I (сокр. от «Idle») — процесс бездействует.
R (сокр. от «Running») — процесс выполняется (или поставлен в очередь на выполнение).
Z (сокр. от «Zombie») — зомби-процесс.
%CPU — процент используемых ресурсов процессора.
%MEM — процент используемой памяти.
TIME+ — количество процессорного времени, потраченного на выполнение процесса.
COMMAND — имя процесса (команды).
Также в сочетании с основными символами состояния процесса (S от «STATUS») вы можете встретить и дополнительные:
— процесс с высоким приоритетом;
N — процесс с низким приоритетом;
l — многопоточный процесс;
Примечание: Все процессы объединены в сессии. Процессы, принадлежащие к одной сессии, определяются общим идентификатором сессии — идентификатором процесса, который создал эту сессию. Лидер сессии — это процесс, идентификатор сессии которого совпадает с его идентификаторами процесса и группы процессов.
Команда glances
Команда glances — это относительно новый инструмент мониторинга системы с расширенными функциями:
Примечание: Если в вашей системе отсутствует данная утилита, то установить её можно с помощью следующих команд:
$ sudo apt-get update
$ sudo apt-get install glances
Управление процессами в Linux
Также в Linux присутствуют некоторые команды для управления процессами:
kill — посылает процессу сигнал завершения работы;
pkill — завершает процесс по его имени;
pgrep — ищет процесс по его имени (и, опционально, по имени запустившего его пользователя);
killall — завершает все активные процессы.
Ниже приведены несколько основных примеров их использования:
Отправка сигналов процессам
Основополагающим способом управления процессами в Linux является отправка им соответствующих сигналов. Для перечисления списка всех доступных сигналов, введите команду:
Большинство сигналов предназначены для внутреннего использования системой или для программистов, когда они пишут код. Ниже приведены наиболее полезные сигналы:
SIGHUP (1) — отправляется процессу, когда его управляющий терминал закрыт.
SIGINT (2) — отправляется процессу управляющим терминалом, когда пользователь прерывает процесс нажатием клавиш Ctrl+C.
SIGQUIT (3) — отправляется процессу, если пользователь посылает сигнал выхода Ctrl+D.
SIGKILL (9) — этот сигнал немедленно завершает (убивает) процесс, и процесс не будет выполнять никаких операций очистки за собой.
SIGTERM (15) — сигнал завершения программы (отправляется командой kill по умолчанию).
SIGTSTP (20) — отправляется процессу управляющим терминалом с запросом на остановку; инициируется пользователем нажатием клавиш Ctrl+Z.
Ниже приведены примеры команды kill для уничтожения приложения firefox с помощью PID, после его зависания:
Изменение приоритета процесса
В системе Linux все активные процессы имеют определенный приоритет выполнения, задаваемый так называемым nice-значением. Процессы с более высоким приоритетом обычно получают больше процессорного времени, чем процессы с более низким приоритетом. Однако пользователь с root-правами может повлиять на это с помощью команд nice и renice.
Узнать значение приоритета команды можно по выводу команды top (столбец NI):
Чем больше nice-значение, тем меньшим приоритетом будет обладать процесс. Например, вы можете задать приоритет для запускаемого процесса следующим образом:
Чтобы изменить приоритет уже запущенного процесса, используйте команду renice следующим образом:
$ renice +8 5547
$ renice +8 1151
На данный момент это всё! Если у вас есть какие-либо вопросы или дополнительные идеи, вы можете поделиться ими с нами с помощью комментариев.
Поделиться в социальных сетях:
Процесcы в операционной системе Linux (основные понятия)
Основными активными сущностями в системе Linux являются процессы. Каждый процесс выполняет одну программу и изначально получает один поток управления. Иначе говоря, у процесса есть один счетчик команд, который отслеживает следующую исполняемую команду. Linux позволяет процессу создавать дополнительные потоки (после того, как он начинает выполнение).
Linux представляет собой многозадачную систему, так что несколько независимых процессов могут работать одновременно. Более того, у каждого пользователя может быть одновременно несколько активных процессов, так что в большой системе могут одновременно работать cотни и даже тысячи процессов. Фактически на большинстве однопользовательских рабочих станций (даже когда пользователь куда-либо отлучился) работают десятки фоновых процессов, называемых демонами (daemons). Они запускаются при загрузке системы из сценария оболочки.
Типичным демоном является cron. Он просыпается раз в минуту, проверяя, не нужно ли ему что-то сделать. Если у него есть работа, то он ее выполняет, а затем отправляется спать дальше (до следующей проверки).
Этот демон позволяет планировать в системе Linux активность на минуты, часы, дни и даже месяцы вперед. Например, представьте, что пользователю назначено явиться во военкомат в 3 часа дня в следующий вторник. Он может создать запись в базе данных демона cron, чтобы тот просигналил ему, скажем, в 14:30. Когда наступает назначенный день и время, демон cron видит, что у него есть работа, и запускает в назначенное время программу звукового сигнала (в виде нового процесса).
Демон cron также используется для периодического запуска задач, например ежедневного резервного копирования диска в 4 часа ночи или напоминания забывчивым пользователям каждый год за неделю до 31 декабря купить подарки для празднования нового года. Другие демоны управляют входящей и исходящей электронной почтой, очередями принтера, проверяют, достаточно ли еще осталось свободных страниц памяти и т.д. Демоны реализуются в системе Linux довольно просто, так как каждый из них представляет собой отдельный процесс, независимый от всех остальных процессов.
Процессы создаются в операционной системе Linux очень просто. Системный вызов fork создает точную копию исходного процесса, называемого родительским процессом (parent process). Новый процесс называется дочерним процессом (child process). У родительского и у дочернего процессов есть свои собственные (приватные) образы памяти. Если родительский процесс впоследствии изменяет какие-либо свои переменные, то эти изменения остаются невидимыми для дочернего процесса (и наоборот).
Открытые файлы используются родительским и дочерним процессами совместно. Это значит, что если какой-либо файл был открыт в родительском процессе до выполнения системного вызова fork, то он останется открытым в обоих процессах и в дальнейшем. Изменения, произведенные с этим файлом любым из процессов, будут видны другому. Такое поведение является единственно разумным, так как эти изменения будут видны также и любому другому процессу, который тоже откроет этот файл.
Тот факт, что образы памяти, переменные, регистры и все остальное и у родительского процесса, и у дочернего идентичны, приводит к небольшому затруднению: как процессам узнать, который из них должен исполнять родительский код, а который дочерний? Секрет в том, что системный вызов fork возвращает дочернему процессу число 0, а родительскому — отличный от нуля PID (Process IDentifier — идентификатор процесса) дочернего процесса. Оба процесса обычно проверяют возвращаемое значение и действуют соответственно:
pid = fork( ); /* если fork завершился успешно, pid > 0 в родительском процессе */
if (pid 0) <
/* здесь располагается родительский код */
> else <
/* здесь располагается дочерний код */
>
Если дочерний процесс желает узнать свой PID, то он может воспользоваться системным вызовом getpid. Идентификаторы процессов используются различным образом. Например, когда дочерний процесс завершается, его родитель получает PID только что завершившегося дочернего процесса. Это может быть важно, так как у родительского процесса может быть много дочерних процессов. Поскольку у дочерних процессов также могут быть дочерние процессы, то исходный процесс может создать целое дерево детей, внуков, правнуков и более дальних потомков.
В системе Linux процессы могут общаться друг с другом с помощью некой формы передачи сообщений. Можно создать канал между двумя процессами, в который один процесс сможет писать поток байтов, а другой процесс сможет его читать. Эти каналы иногда называют трубами (pipes). Синхронизация процессов достигается путем блокирования процесса при попытке прочитать данные из пустого канала. Когда данные появляются в канале, процесс разблокируется.
При помощи каналов организуются конвейеры оболочки. Когда оболочка видит строку вроде
sort
Процессы и потоки в ОС LINUX
Цель работы – исследовать методы создания процессов в ОС Linux, основные функции создания и управления процессами, обмен данными между процессами.
Теоретическая часть
В ОС Linux для создания процессов используется системный вызов fork():
#include
#include
pid_t fork (void);
В результате успешного вызова fork() ядро создаёт новый процесс, который является почти точной копией вызывающего процесса. Другими словами, новый процесс выполняет копию той же программы, что и создавший его процесс, при этом все его объекты данных имеют те же самые значения, что и в вызывающем процессе.
Созданный процесс называется дочерним процессом, а процесс, осуществивший вызов fork(), называется родительским. После вызова родительский процесс и его вновь созданный потомок выполняются одновременно, при этом оба процесса продолжают выполнение с оператора, который следует сразу же за вызовом fork(). Процессы выполняются в разных адресных пространствах, поэтому прямой доступ к переменным одного процесса из другого процесса невозможен.
Следующая короткая программа более наглядно показывает работу вызова fork() и использование процесса:
#include
#include
Int main ()
pid_t pid; /* идентификатор процесса */
printf (“Пока всего один процесс\n”);
pid = fork (); /* Создание нового процесса */
printf (“Уже два процесса\n”);
if (pid = = 0)
printf (“Это Дочерний процесс его pid=%d\n”, getpid());
printf (“А pid его Родительского процесса=%d\n”, getppid());
else if (pid > 0)
printf (“Это Родительский процесс pid=%d\n”, getpid());
Else
printf (“Ошибка вызова fork, потомок не создан\n”);
Для корректного завершения дочернего процесса в родительском процессе необходимо использовать функцию wait() или waitpid():
pid_t wait(int *status);
pid_t waitpid(pid_t pid, int *status, int options);
Функция wait приостанавливает выполнение родительского процесса до тех пор, пока дочерний процесс не прекратит выполнение или до появления сигнала, который либо завершает текущий процесс, либо требует вызвать функцию-обработчик. Если дочерний процесс к моменту вызова функции уже завершился (так называемый «зомби»), то функция немедленно возвращается. Системные ресурсы, связанные с дочерним процессом, освобождаются.
Функция waitpid приостанавливает выполнение родительского процесса до тех пор, пока дочерний процесс, указанный в параметре pid, не завершит выполнение, или пока не появится сигнал, который либо завершает родительский процесс, либо требует вызвать функцию-обработчик. Если указанный дочерний процесс к моменту вызова функции уже завершился (так называемый «зомби»), то функция немедленно возвращается. Системные ресурсы, связанные с дочерним процессом, освобождаются. Параметр pid может принимать несколько значений:
pid 0 означает ожидать дочернего процесса, чем идентификатор равен pid.
Значение options создается путем битовой операции ИЛИ над следующими константами:
Каждый дочерний процесс при завершении работы посылает своему процессу-родителю специальный сигнал SIGCHLD, на который у всех процессов по умолчанию установлена реакция «игнорировать сигнал». Наличие такого сигнала совместно с системным вызовом waitpid() позволяет организовать асинхронный сбор информации о статусе завершившихся порожденных процессов процессом-родителем.
Для перегрузки исполняемой программы можно использовать функции семейства exec. Основное отличие между разными функциями в семействе состоит в способе передачи параметров.
int execv(char *pathname, char *argv[]);
int execve(char *pathname, char *argv[],char **envp);
int execvp(char *pathname, char *argv[]);
int execvpe(char *pathname, char *argv[],char **envp);
Существует расширенная реализация понятия процесс, когда процесс представляет собой совокупность выделенных ему ресурсов и набора нитей исполнения. Нити(threads) или потокипроцесса разделяют его программный код, глобальные переменные и системные ресурсы, но каждая нить имеет собственный программный счетчик, свое содержимое регистров и свой стек. Все глобальные переменные доступны в любой из дочерних нитей. Каждая нить исполнения имеет в системе уникальный номер – идентификатор нити. Поскольку традиционный процесс в концепции нитей исполнения трактуется как процесс, содержащий единственную нить исполнения, мы можем узнать идентификатор этой нити и для любого обычного процесса. Для этого используется функция pthread_self(). Нить исполнения, создаваемую при рождении нового процесса, принято называть начальной или главной нитью исполнения этого процесса. Для создания нитей используется функция pthread_create:
int pthread_create( pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine)( void*), void *arg);
void * start_routine (void *)
Завершение функции потока происходит если:
· функция нити вызвала функцию pthread_exit();
· функция нити достигла точки выхода;
· нить была досрочно завершена другой нитью.
Функция pthread_join() используется для перевода нити в состояние ожидания:
int pthread_join (pthread_t thread, void **status_addr);
Функция pthread_join() блокирует работу вызвавшей ее нити исполнения до завершения нити с идентификатором thread. После разблокирования в указатель, расположенный по адресу status_addr, заносится адрес, который вернул завершившийся thread либо при выходе из ассоциированной с ним функции, либо при выполнении функции pthread_exit(). Если нас не интересует, что вернула нам нить исполнения, в качестве этого параметра можно использовать значение NULL.
Для компиляции программы с нитями необходимо подключить библиотеку pthread.lib следующим способом:
Время в Linux отсчитывается в секундах, прошедшее с начала этой эпохи (00:00:00 UTC, 1 Января 1970 года). Для получения системного времени можно использовать следующие функции:
#include
time_t time (time_t *tt);
int gettimeofday(struct timeval *tv, struct timezone *tz);
struct timeval <
long tv_sec; /* секунды */
long tv_usec; /* микросекунды */
Порядок выполнения работы
1. Изучить теоретическую часть работы.
3. В основной программе создать 2 потока. После этого процесс-отец создает файл, записывает в него строки вида: N pid текущее время в формате: часы: минуты: секунды: миллисекунды (где N – номер выводимой строки) и выводит формируемые строки в левой половине экрана. Количество записываемых в файл строк k = 100. Оба потока читают строки из файла и выводят их в правой части экрана в виде: потокid потока текущее время (мсек) строка из файла
Варианты индивидуальных заданий
1. Разработать программу по условию п.3, но вместо потоков создать 3 процесса, которые осуществляют те же функции, что и в п.3 (читают строки из файла и выводят их в правой части экрана) в виде: процессpid процесса текущее время (мсек) строка из файла.
2. Написать программу нахождения массива K последовательных значений функции y[i]=sin(2*PI*i/N)( i=0,1,2…K-1 ) с использованием ряда Тейлора. Пользователь задаёт значения K, N и количество n членов ряда Тейлора. Для расчета каждого члена ряда Тейлора запускается отдельная нить. Каждая нить выводит на экран свой id и рассчитанное значение ряда. Головной процесс суммирует все члены ряда Тейлора, и полученное значение y[i] записывает в файл.
3. Написать программу синхронизации двух каталогов, например, Dir1 и Dir2. Пользователь задаёт имена Dir1 и Dir2. В результате работы программы файлы, имеющиеся в Dir1, но отсутствующие в Dir2, должны скопироваться в Dir2 вместе с правами доступа. Процедуры копирования должны запускаться с использованием функции fork() в отдельном процессе для каждого копируемого файла. Каждый процесс выводит на экран свой pid, имя копируемого файла и число скопированных байт. Число запущенных процессов не должно превышать N (вводится пользователем).
4. Написать программу поиска одинаковых по их содержимому файлов в двух каталогов, например, Dir1 и Dir2. Пользователь задаёт имена Dir1 и Dir2. В результате работы программы файлы, имеющиеся в Dir1, сравниваются с файлами в Dir2 по их содержимому. Процедуры сравнения должны запускаться с использованием функции fork() в отдельном процессе для каждой пары сравниваемых файлов. Каждый процесс выводит на экран свой pid, имя файла, число просмотренных байт и результаты сравнения. Число запущенных процессов не должно превышать N (вводится пользователем).
5. Написать программу поиска заданной пользователем комбинации из m байт (m