Посмотреть последовательно несколько раз ps f записать сообщение объяснить
Обновлено: 05.07.2024
while true; do true; done while true; do true; echo ‘Hello’; done 19. Запустить loop2 на переднем плане: sh loop2.
20. Остановить, послав сигнал STOP.
23. Запустить в фоне процесс loop: sh loop&. Не останавливая, посмотреть несколько раз: ps –f.
Записать значение, объяснить.
25. Третий раз запустить в фоне. Не останавливая убить командой kill -9 PID.
26. Запустить несколько процессов в фоне. Останавливать их и снова запускать. Записать результаты просмотра командой ps –f.
Контрольные вопросы 1. Что такое файловая система?
2. Жесткая ссылка в Linux. Основные сведения.
3. Команда поиска в Linux. Основные сведения.
4. Перечислите основные команды работы с каталогами.
5. Как остановить процесс?
Закрепить теоретические знания и получить практический навык работы с операционной системой UNIX.
Краткие теоретические сведения.
Процесс загрузки UNIX достаточно сложен и длителен, но через некоторое время появится приглашение на ввод имени пользователя: “DarkStar login:”. Первое слово “DarkStar” определяет имя машины, на которой вы собираетесь работать, поэтому для разных компьютеров оно будет различно, а может и вообще отсутствовать. В ответ на это приглашение нужно ввести свое имя, которое вам выделил администратор сети. Существует несколько стандартных имен, не требующих пароля. Попробуйте: student, anonymous или guest. Далее в ответ на запрос пароля (password) введите свой пароль или, если имя не требует пароля, просто нажмите клавишу ENTER.
В случае удачной регистрации UNIX выдает подсказку(промптер) для ввода команд.
Системная консоль - это монитор и клавиатура, связанные непосредственно с системой.
(Поскольку UNIX - многопользовательская система, Вы можете иметь дополнительные терминалы, связанные через последовательные порты с вашей системой, но они не будут консолями). Linux, как и некоторые другие версии UNIX, обеспечивает доступ к виртуальным консолям (или VC), которые позволяют войти в систему под несколькими именами в одно время.
Для демонстрации этого войдите в систему (как было показано ранее). Теперь нажмите alt-F2. Вы должны снова увидеть подсказку login:, то есть перед Вами вторая виртуальная консоль, а Вы вошли через первую. Чтобы переключиться обратно на первую VC, нажмите altF1. Вы снова на первой консоли. Возможно обеспечить работу с 12-ю VC - по одной на каждую функциональную клавишу. Использование VC может быть очень эффективным - Вы можете работать на нескольких VC одновременно. В то время, как использование виртуальных консолей ограничено (кроме прочего, в каждый момент времени можно видеть только одну виртуальную консоль), оно дает представление о многопользовательских возможностях UNIX.
В этом пункте будут описаны стандартные операции, выполняемые UNIX при загрузке.
Некоторые термины здесь могут быть сразу не совсем понятными, поэтому при первом чтении можно пропустить этот пункт, но обязательно вернуться к нему после прочтения всей методической работы.
Системные входные процедуры содержат команды, которые устанавливают среду пользователя. Системные входные процедуры исполняютсяраньше, чем локальная входная процедура пользователя.
Локальные входные процедуры могут отменять или модифицировать системные значения по умолчанию для индивидуальных пользователей. При добавлении новых пользователей в систему администратор должен быть уверен, что этот пользователь имеет локальную входную процедуру. В UNIX имеются четыре локальные входные процедуры, которые можно скопировать в начальный каталог пользователя:
каталог /etc/skel можно содержимое /etc/skel (обеспечивающее скелет начального каталога нового пользователя) копируется в начальный каталог нового пользователя, отражая структуру самого каталога /etc/skel.
При входе в систему нового пользователя UNIX должен прежде всего выполнить ряд шагов для инициализации своей среды:
1. Shell(оболочка или ядро UNIX) запускает соответствующую системную входную процедуру, которая инициализирует среду пользователя. Системные входные процедуры определяют среду по умолчанию и могут быть настроены системным администратором.
Ограниченный (/usr/bin/rsh,/usr/bin/rksh) /etc/profile Данные процедуры определяют и экспортируют для shell'a используемые переменные являются /etc/MANPATH и /etc/TIMEZONE. Так как системные входные процедуры исполняются для всех пользователей при их входе в систему, системный администратор может модифицировать их так, чтобы установить для всех пользователей общие значения по умолчанию. Это полезно, когда необходимо быть уверенным в том, что каждый пользователь выполняет важные команды при входе в систему.
3. Информирует пользователя о непрочитанных новостях, выводя приглашение в виде: news: имя_файла_новостей 4. Shell запускает локальные входные процедуры пользователя (если они существуют) из начального каталога пользователя (переменная $HOME):
Обычно системный администратор сначала создает локальную входную процедуру для каждого пользователя. Он копирует в начальный каталог пользователя локальную входную процедуру по умолчанию (файл /etc/skel/.файл). Пользователи в дальнейшем настраивают сами свою среду, модифицируя этот файл в соответствии со своими потребностями.
Кроме перечисленных выше процедур, Коrn Shell и С Shell могут иметь (и обычно имеют) дополнительные локальные входные процедуры:
• Кorn Shell — если переменная среды ENV определена, Коrn shell исполняет файл, заданный ею (обычно это.kshrc); файл исполняется каждый раз, когда запускается новый Кorn Shell. Многие программы (например, vi и mailx) позволяют пользователю запускать shell из этих программ; это называетсявыходом в shell. Файл $ENV перезапускается при каждом выходе в shell, тогда как.profile запускается только при входе в систему.
• С Shell — каждый раз, когда запускается новый С shell, выполняется файл.cshrc. Это аналогично тому, как работает файл $ENV для Кorn Shell'a.Файл.login запускается только при входе в систему, тогда как файл.cshrc исполняется для каждого нового С shell.
5. Как только вся инициализация выполнена, shell выводит приглашение и ждет ввода от пользователя.
Прежде всего необходимо отметить, что UNIX является системой, чувствительной к регистру букв. В основном, все команды вводятся строчными (маленькими) буквами. Если регистр букв будет неверным, UNIX не сможет обработать введенную команду.
В UNIX большинство команд - это исполняемые файлы. Однако есть и встроенные (внутренние) команды, для которых не требуется наличие исполняемых файлов. Их перечень приведен в прил.2.
Для изучения формата команд в UNIX есть специальная команда man, позволяющая выдать полное описание любой команды, переданной ей в качестве аргумента. Например, введем следующую команду: man man. После этого на экран будет выдано полное руководство по команде man. Если ввести man echo, то UNIX выдаст на экран описание команды echo.
Опции или флаги команд обычно начинаются с ‘-’. Во многих случаях несколько однобуквенных опций могут следовать за одним минусом. Например, вместо использования ls l -F можно использовать ls -lF.
Многие из команд берут список файлов или каталогов как аргументы, обозначенные как следует имя целевого файла или каталога. При копировании нескольких файлов в качестве целевого может выступать только каталог.
Изменяет текущий рабочий каталог.
Аргумент directory – это каталог, в который необходимо перейти (’.’ ссылается на текущий каталог, ‘..’ – на родительский каталог).
Пример: cd../foo переводит из текущего каталога в../foo.
Выдает информацию о файлах в каталоге.
Синтаксис: ls file1. fileN.
Аргументы file1. fileN – это имена файлов или каталогов, информацию про которые надо выдать. Наиболее часто используемые опции:
-F (для представления информации о типах файлов), и -l (выдает в длинном (long) формате информацию о размерах файлов, владельцах, правах доступа и т.д.
Пример: ls -lF /home/larry выдаст содержимое каталога /home/larry.
Копирует файл(ы) в файл или каталог.
Синтаксис: cp file1. fileNdestination.
Аргументы file1. fileN – это имена копируемых файлов, а destination файл или каталог, в который копируют.
На этом занятии мы поговорим, как в Python можно считывать информацию из файлов и записывать ее в файлы. Что такое файлы и зачем они нужны, думаю объяснять не надо, т.к. если вы дошли до этого занятия, значит, проблем с пониманием таких базовых вещей у вас нет. Поэтому сразу перейдем к функции
open(file [, mode=’r’, encoding=None, …])
- file – это путь к файлу вместе с его именем;
- mode – режим доступа к файлу;
- encoding – кодировка файла.
Тогда, чтобы обратиться к файлу my_file.txt путь можно записать так:
Последние два варианта представляют собой абсолютный путь к файлу, то есть, полный путь, начиная с указания диска. Причем, обычно используют обратный слеш в качестве разделителя: так короче писать и такой путь будет корректно восприниматься как под ОС Windows, так и Linux. Первый же вариант – это относительный путь, относительно рабочего каталога.
Теперь, предположим, мы хотим обратиться к файлу img.txt. Это можно сделать так:
Для доступа к out.txt пути будут записаны так:
Обратите внимание, здесь две точки означают переход к родительскому каталогу, то есть, выход из каталога app на один уровень вверх.
И, наконец, для доступа к файлу prt.dat пути запишутся так:
В результате переменная file будет ссылаться на файловый объект, через который и происходит работа с файлами. Если указать неверный путь, например, так:
то возникнет ошибка FileNotFoundError. Это стандартное исключение и как их обрабатывать мы с вами говорили на предыдущем занятии. Поэтому, запишем этот критический код в блоке try:
Изменим имя файла на верное и посмотрим, как далее можно с ним работать. По умолчанию функция open открывает файл в текстовом режиме на чтение. Это режим
Если нам нужно поменять режим доступа к файлу, например, открыть его на запись, то это явно указывается вторым параметром функции open:
- 'rt' – чтение в текстовом режиме;
- 'wb' – запись в бинарном режиме;
- 'a+' – дозапись или чтение данных из файла.
Чтение информации из файла
В чем отличие текстового режима от бинарного мы поговорим позже, а сейчас откроем файл на чтение в текстовом режиме:
и прочитаем его содержимое с помощью метода read:
Теперь все будет работать корректно. Далее, в методе read мы можем указать некий числовой аргумент, например,
Тогда из файла будут считаны первые два символа. И смотрите, если мы запишем два таких вызова подряд:
то увидим, что при следующем вызове метод read продолжил читать следующие два символа. Почему так произошло? Дело в том, что у файлового объекта, на который ссылается переменная file, имеется внутренний указатель позиции (file position), который показывает с какого места производить считывание информации.
Когда мы вызываем метод read(2) эта позиция автоматически сдвигается от начала файла на два символа, т.к. мы именно столько считываем. И при повторном вызове read(2) считывание продолжается, т.е. берутся следующие два символа. Соответственно, позиция файла сдвигается дальше. И так, пока не дойдем до конца.
Но мы в Python можем управлять этой файловой позицией с помощью метода
Например, вот такая запись:
будет означать, что мы устанавливаем позицию в начало и тогда такие строчки:
будут считывать одни и те же первые символы. Если же мы хотим узнать текущую позицию в файле, то следует вызвать метод tell:
Следующий полезный метод – это readline позволяет построчно считывать информацию из текстового файла:
Здесь концом строки считается символ переноса ‘\n’, либо конец файла. Причем, этот символ переноса строки будет также присутствовать в строке. Мы в этом можем убедиться, вызвав дважды эту функцию:
Здесь в консоли строчки будут разделены пустой строкой. Это как раз из-за того, что один перенос идет из прочитанной строки, а второй добавляется самой функцией print. Поэтому, если их записать вот так:
то вывод будет построчным с одним переносом.
Если нам нужно последовательно прочитать все строчки из файла, то для этого обычно используют цикл for следующим образом:
Этот пример показывает, что объект файл является итерируемым и на каждой итерации возвращает очередную строку.
Или же, все строчки можно прочитать методом
и тогда переменная s будет ссылаться на упорядоченный список с этими строками:
Однако этот метод следует использовать с осторожностью, т.к. для больших файлов может возникнуть ошибка нехватки памяти для хранения полученного списка.
По сути это все методы для считывания информации из файла. И, смотрите, как только мы завершили работу с файлом, его следует закрыть. Для этого используется метод close:
Конечно, прописывая эту строчку, мы не увидим никакой разницы в работе программы. Но, во-первых, закрывая файл, мы освобождаем память, связанную с этим файлом и, во-вторых, у нас не будет проблем в потере данных при их записи в файл. А, вообще, лучше просто запомнить: после завершения работы с файлом, его нужно закрыть. Причем, организовать программу лучше так:
Мы здесь создаем вложенный блок try, в который помещаем критический текст программы при работе с файлом и далее блок finally, который будет выполнен при любом стечении обстоятельств, а значит, файл гарантированно будет закрыт.
Или же, забегая немного вперед, отмечу, что часто для открытия файла пользуются так называемым менеджером контекста, когда файл открывают при помощи оператора with:
При таком подходе файл закрывается автоматически после выполнения всех инструкций внутри этого менеджера. В этом можно убедиться, выведем в консоль флаг, сигнализирующий закрытие файла:
Запустим программу, видите, все работает также и при этом файл автоматически закрывается. Даже если произойдет критическая ошибка, например, пропишем такую конструкцию:
то, как видим, файл все равно закрывается. Вот в этом удобство такого подхода при работе с файлами.
Запись информации в файл
Теперь давайте посмотрим, как происходит запись информации в файл. Во-первых, нам нужно открыть файл на запись, например, так:
и далее вызвать метод write:
Далее сделаем такую операцию: запишем метод write следующим образом:
то прежнее содержимое файла удаляется. Вот этот момент следует всегда помнить.
Теперь посмотрим, что будет, если вызвать метод write несколько раз подряд:
Смотрите, у нас в файле появились эти строчки друг за другом. То есть, здесь как и со считыванием: объект file записывает информацию, начиная с текущей файловой позиции, и автоматически перемещает ее при выполнении метода write.
Если мы хотим записать эти строчки в файл каждую с новой строки, то в конце каждой пропишем символ переноса строки:
Далее, для дозаписи информации в файл, то есть, записи с сохранением предыдущего содержимого, файл следует открыть в режиме ‘a’:
Тогда, выполняя эту программу, мы в файле увидим уже шесть строчек. И смотрите, в зависимости от режима доступа к файлу, мы должны использовать или методы для записи, или методы для чтения. Например, если вот здесь попытаться прочитать информацию с помощью метода read:
то возникнет ошибка доступа. Если же мы хотим и записывать и считывать информацию, то можно воспользоваться режимом a+:
Так как здесь файловый указатель стоит на последней позиции, то для считывания информации, поставим его в самое начало:
А вот запись данных всегда осуществляется в конец файла.
Следующий полезный метод для записи информации – это writelines:
Он записывает несколько строк, указанных в коллекции. Иногда это бывает удобно, если в процессе обработки текста мы имеем список и его требуется целиком поместить в файл.
Чтение и запись в бинарном режиме доступа
Что такое бинарный режим доступа? Это когда данные из файла считываются один в один без какой-либо обработки. Обычно это используется для сохранения и считывания объектов. Давайте предположим, что нужно сохранить в файл вот такой список:
Откроем файл на запись в бинарном режиме:
Далее, для работы с бинарными данными подключим специальный встроенный модуль pickle:
И вызовем него метод dump:
Все, мы сохранили этот объект в файл. Теперь прочитаем эти данные. Откроем файл на чтение в бинарном режиме:
и далее вызовем метод load модуля pickle:
Все, теперь переменная bs ссылается на эквивалентный список:
Аналогичным образом можно записывать и считывать сразу несколько объектов. Например, так:
А, затем, считывание в том же порядке:
Вот так в Python выполняется запись и считывание данных из файла.
Задания для самоподготовки
1. Выполните считывание данных из текстового файла через символ и записи прочитанных данных в другой текстовый файл. Прочитывайте так не более 100 символов.
2. Пользователь вводит предложение с клавиатуры. Разбейте это предложение по словам (считать, что слова разделены пробелом) и сохраните их в столбец в файл.
3. Пусть имеется словарь:
Необходимо каждый элемент этого словаря сохранить в бинарном файле как объект. Затем, прочитать этот файл и вывести считанные объекты в консоль.
Видео по теме
© 2022 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта
Цель работы: Ознакомиться на практике с понятием процесса в операционной системе. Приобрести опыт и навыки управления процессами в операционной системе Linux.
План проведения занятия
1. Используя теоретические сведения изучить порядок работы с текстовым редактором Vi и создать два сценария для исследования процессов.
2. Следуя указаниям ознакомиться на практике с командами и сигналами для управления процессами: запуском, остановкой, переводом на передний план, удалением процесса и др.
3. Составить отчет.
Краткие теоретические сведения
1. Устройство Linux: ядро и процессы
Главная, постоянно находящаяся в оперативной памяти, часть ОС Linux называется ядром (Kernel). Ядро ОС обрабатывает прерывания от устройств, выполняет запросы системных процессов и пользовательских приложений, распределяет виртуальную память, создает и уничтожает процессы, обеспечивает многозадачность посредством переключения между ними, содержит драйверы устройств, обслуживает файловую систему (см. рис. 34).
Пользовательские процессы не могут непосредственно, например, порождать другие процессы, производить чтение или запись на диск, выводить данные на экран или создавать гнездо (socket) для обмена по сети. Для выполнения этих действий они должны воспользоваться сервисами ядра. Обращения за такими услугами называются системными
Рис. 34. Устройство Linux
Начальная загрузка системы состоит в том, что файл с образом ядра счи-тывается в оперативную память, начиная с нулевого адреса. Этот файл находится в каталоге /boot и называется vmlinuz-x.y.z, где x.y.z — это номер версии ядра. На текущий момент большинство дистрибутивов основано на ядре версии 2.4, хотя уже вышло ядро 2.6 и коегде еще встречается версия 2.2.
В UNIX-подобных системах в отличие от других ОС ядро минимизировано и не выполняет ни одной функции, служащей непосредственно пользователю. Для этой
цели применяются многочисленные утилиты, выступающие в качестве посредников между пользователем и ядром. Только в комплекте с ними ядро образует полноценную операционную систему.
Ядро обслуживает запросы процессов. Что же такое процесс? Это понятие является базовым в UNIX-подобных системах. Процесс можно представить себе как виртуальную машину, отданную в распоряжение одной задачи. Каждый процесс считает, что он на машине один и может распоряжаться всеми ее ресурсами. На самом же деле процессы надежно изолированы друг от друга, так что крушение одного не может повредить всей системе
Каждый процесс выполняется в собственной виртуальной памяти, в которую никакой другой процесс вмешаться не может. Этим и обеспечивается устойчивость всей системы.
Напомним, что такое виртуальная память. Каждому процессу разрешено считать, что его адреса начинаются с нулевого адреса и далее наращиваются. Таким образом, в 32разрядной ОС процесс может адресовать 4 гигабайта оперативной памяти. Механизм виртуальной памяти позволяет процессу считать, что именно столько ему и выделено, хотя физически объем ОЗУ вашей машины может быть значительно меньше. Недостающую память заменяет жесткий диск путем записи временно не используемых страниц памяти в раздел подкачки (свопинга).
Разделяемость библиотек между процессами обеспечивается тем, что их код и статические данные отображаются на один и тот же участок физической оперативной памяти.
С точки зрения ядра процесс представляет собой запись в таблице процессов. Эта запись содержит сведения о состоянии процесса и данные, существующие в течение всего времени его жизни. Размер таблицы процессов позволяет запускать несколько сотен процессов одновременно. Другая важная информация о процессе — например, таблица всех открытых процессом файлов — хранится в его адресном пространстве. Запись в таблице процессов и пространство процесса вместе составляют контекст, или окружение, процесса. В него входят:
♦ PID — идентификатор процесса. Он принудительно назначается планировщиком при запуске процесса.
♦ PPID — идентификатор родительского процесса.
♦ TTY — имя управляющего терминала - терминала, с которого запущен процесс.
♦ WD — текущий каталог процесса, от которого отсчитываются относительные пути.
♦ RID, RGID — реальные ID и групповой ID пользователя, запустившего процесс.
♦ EUID, EGID — эффективные ID и GID.
♦ NICE — показатель уступчивости. Процессы выполняются в режиме разделения времени, то есть время центрального процессора делится между готовыми к выполнению процессами с учетом их приоритета. Чем выше показатель уступчивости, тем ниже приоритет.
Системные вызовы fork() и ехес() или как размножаются процессы
Каждый процесс порождается другим процессом, использующим для этого системный вызов fork(). Таким образом, структура процессов, подобно файловой системе, древовидна. Корнем этого дерева служит init — процесс инициализации системы (см. рис. 35). Он запускается ядром первым, получает идентификатор 1 и порождает еще несколько процессов (сколько и каких, можно узнать из его конфигурационного файла /etc/inittab), которые, в свою очередь, при участии пользователя порождают другие процессы.
В результате системного вызова fork() родительский процесс полностью копирует свое окружение, включая адресное пространство, в дочерний, так что в момент
рождения дочерний процесс отличается только своим ID. Потом дочерний процесс с помощью вызова ехec() загружает в свое адресное пространство какой-нибудь исполняемый файл и начинает исполнять содержащуюся в нем программу.
Каждый процесс, завершившись, возвращает родительскому процессу какое-то значение, называемое кодом завершения или кодом возврата. По соглашению разработчиков, нулевой код возврата означает успешное завершение, а ненулевые — разнообразные ошибки. Процесс-родитель может приостановить свое выполнение до завершения потомка и выполнить разные действия в зависимости от возвращенного дочерним процессом значения, а может и не делать этого.
Рис. 35. Иерархия процессов.
Процессы делятся на три категории:
♦ Системные . Они порождаются ядром особым образом в процессе загрузки и выполняют системные функции (например, планирование процессов или смену страниц виртуальной памяти). Выполняемая имипрограммаберетсянеизисполняемогофайла, аявляетсячастью ядра.
• Пользовательские . Как правило, они порождаются во время сеанса работы пользователя
и связаны с терминалом. Если пользовательский процесс работает в интерактивном режиме, то он захватывает терминал в монопольное владение и, пока он не завершится, пользователь не имеет доступа к командной строке на этом терминале. Пользовательские процессы могут работать также в фоновом режиме, освободив командную строку.
• Демоны ( daemon, сокращение от Disk And Execution MONitor ). Запускаются после инициализации ядра. Выполняются в фоновом режиме, не связаны ни с одним пользователем, обеспечивают работу различных служб (например, управление сетью). Главным демоном считается init — процесс инициализации системы.
2. Сценарии в Linux. Активные и фоновые процессы
Исполняемые файлы в Linux бывают двух видов. Первый – это файлы в собственно исполняемом (executable) формате. Как правило, такие файлы – результат компиляции программ, написанных на одном из языков программирования. В Linux используется несколько форматов исполняемых файлов, состоящих из машинных кодов и служебной информации, необходимой операционной системе для запуска программы: согласно этой информации, ядро Linux выделяет для запускаемой программы оперативную память, загружает программу из файла и передает ей управление. Большинство утилит Linux – программы именно такого, "двоичного" формата.
Второй вид исполняемых файлов – сценарии. Сценарий – это текстовый файл, предназначенный для обработки какой-нибудь утилитой. Чаще всего такая утилита – это интерпретатор некоторого языка программирования, а содержимое такого файла – программа на этом языке.
Запустить сценарий на исполнение можно командой sh имя_сценария
Для того чтобы запустить процесс сценария параллельно, достаточно добавить в конец командной строки символ " & ":
Активный процесс, foreground process - процесс, имеющий возможность вводить данные с терминала. В каждый момент у каждого терминала может быть не более одного активного процесса.
Фоновый процесс, background process - процесс, не имеющий возможности вводить данные с терминала. Пользователь может запустить любое, но не превосходящее заранее заданного в системе, число фоновых процессов.
Сигналы в Linux
Всего в Linux 63 сигнала, обозначаемых своими номерами или символическими именами. Имена всех сигналов начинаются с SIG, и эту приставку часто опускают: так, сигнал, требующий прекратить выполнение процесса, называется SIGKILL, или KILL, или сигнал
Получив сигнал, процесс может: игнорировать его; вызвать для обработки установленную по умолчанию функцию; вызвать собственный обработчик (перехватить сигнал). Некоторые сигналы (например, KILL) перехватить или игнорировать невозможно.
Пользователь может послать сигнал процессу с идентификатором PID командой $ kill [-s ]
где — это номер или символическое имя.
Несколько часто встречающихся сигналов перечислены в таблице 1. Полный список можно получить по команде kill -l (list) .
Моментальный снимок протекающих в системе процессов можно посмотреть с помощью команды ps (process status). Без аргументов она покажет список процессов, связанных с текущей консолью (или виртуальным терминалом). Список возможных ключей команды можно, как обычно, получить по команде ps --help.
Вот некоторые полезные из них:
♦ -р : только процессы с указанными ID;
♦ -u : только процессы, запущенные указанными пользователями;
♦ -е : все процессы в системе;
♦ -f : полная форма вывода;
♦ -Н : вывод иерархии процессов в форме дерева.
Динамика процессов — команда top
Представление о динамике процессов дает команда top. Она выводит список процессов, отсортированный по количеству занятой памяти или использованного процессорного времени, и обновляет его через указанные промежутки времени (по умолчанию через каждые 3 секунды).
Последний процесс, запущенный из оболочки в фоне, можно из этойоболочки сделать активным при помощи команды fg("foreground" – "передний план").
Команда bg(back ground), запускает в фоне последний остановленный процесс.
Командой kill, как уже говорилось, можно передать процессу сигнал. Команда имеет два параметра - номер сигнала и идентификатор процесса, которому передается сигнал: kill –номер_сигнала PID
Порядок выполнения работы:
1) Загрузиться не root, а пользователем.
2) Найти файл c образом ядра. Выяснить по имени файла номер версии Linux.
3) Посмотреть процессы ps –f. Прокомментировать. Для этого почитать man ps.
4) Написать с помощью редактора vi два сценария loop и loop2. Текст сценариев:
while true; do true; done
while true; do true; echo ‘Hello’; done
5) Запустить loop2 на переднем плане: sh loop2.
6) Остановить, послав сигнал STOP.
9) Запустить в фоне процесс loop: sh loop&. Не останавливая, посмотреть несколько раз: ps –f. Записать значение, объяснить.
11) Третий раз запустить в фоне. Не останавливая убить командой kill -9 PID.
12) Запустить еще один экземпляр оболочки: bash.
13) Запустить несколько процессов в фоне. Останавливать их и снова запускать.
Записать результаты просмотра командой ps –f.
Литература
1. Колисниченко Д.Н., Питер В.Аллен. Linux. Полное руководство, 2-е изд. [Текст] - СПб: Наука и техника, 2007. - 784 с.
Читайте также: