Приветствую всех самым категорическим
образом. Помнится, не раз и не два во "мнениях"
проскакивали сообщения типа "… и пишите
побольше о программинге под никсы!".
Танцуйте, господа, мы открываем рубрику под
названием [см. сабж]. Клятвенно заверяю, что
постараемся сделать ее более-менее
регулярной, хотя обещать ничего не могу, ибо
смотреть в будущее с уверенностью — еще не
значит быть уверенным в этом будущем ;-). И
перед тем, как начать, обращу ваше внимание
на две вещи.

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

Во-вторых, обращаюсь к тем, кто уже
навострил клаву писать всякую гадость во
"мнения" и обвинять автора в третьей
степени ламерства. Перцы! Я уверен, что
среди вас есть знающие люди, и рад этому.
Также я уверен, что есть и те, которые
посмеиваются над потугами авторов
втолковать что-то начинающим, и в худших
случаях эти "посмеивания" выливаются в
мнения типа "Ну ты ламо, такие вещи писать,
ваще все это сто лет назад узнали". И к
таким у меня вопрос: а не лучше ли, вместо
этого, сеть и самим написать материал в
колонку, раз вы так все хорошо знаете? Это
куда как достойнее испражнения в ослоумии,
и все будут только рады. Все, я все сказал.
Теперь — к делу. Те, кто не хочет изучать
умные скучные книжки об устройстве UNIX и о
программинге на Си, но любит посещать xakep.ru,
приготовьтесь нехило прогрузиться! 8-).

Начнем мы наш экскурс с осознания того, в
чем, собственно, состоит гибкость никсов по
сравнению с другими осями. Если кто не знает,
все в нем состоит из отдельных процессов,
взаимодействующих между собой.. То есть
выводишь ты текст на экран — это один
процесс, пишешь в файл — другой процесс,
запускаешь прогу — она, в свою очередь, есть
еще один процесс. Процесс, не побоюсь этого
слова, есть центральная фича юникса 8-). То
есть, это — отдельно выполняющаяся
программа, имеющая вполне фиксированный
доступ к ресурсам машины. Если у себя в
юнихе ты наберешь:

$ ps

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

$ tar cvf — file1.jpg file2.jpg file3.jpg | gzip -5 >
mylittlepornoarchive.tar.gz

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

Что еще нужно знать, прежде чем приступить
работать с процессами? Когда ты выводил их
список, ты, конечно, увидел у каждого некие
цифры под подписью PID. Это есть ни что иное,
как process identificator — логично, не правда ли,
чтобы каждый из тьмы процессов имел
собственный идентификатор, а то как же его
выцеплять из тысячи остальных? Также, в силу
того, что процессы порождаются и умирают
все время (посмотри, когда ты набирал $ ps [enter],
ты сделал ни что иное, как создал процесс (все
в никсе делают процессы, помнишь?) ps, который
занимается тем, что выводит список
процессов, включая и себя, конечно. Как
только он сделал все, что от него требуется —
список вывел — он умирает, дабы не занимать
процессорные ресурсы), так вот, в силу того,
что процессы рождаются и умирают постоянно,
каждый процесс имеет не только PID —
идентификатор себя, но и PPID — parent PID, т.е.
идентификатор своих "родителей", того
процесса, который его породил. В данном
случае, очевидно, процесс ps порожден
процессом tty — вводом с консоли.

Ну да это все пустое гонево, скажешь ты,
при чем же тут программинг? Отлично,
переходим к написанию проги, цель наша —
научиться управлять процессами, то есть
создавать их, передавать им управление,
заставлять их делать что-нибудь полезное,
ну и убивать их, естественно 8-). Думаешь, это
трудно? Ничуть. Все, что тебе потребуется
знать (при условии, что ты более-менее
сносно знаешь Си), это пара-тройка чисто
юниксовых функций.

Порождает процессы функция fork(). Синтаксис
у нее такой: возвращает ноль, если процесс
создан успешно, и -1 — если нет. Реализовать,
соответственно, можно по-разному. ИМХО,
самое очевидное — через функцию выбора switсh-case,
так как это более наглядно, чем строить
конструкции типа if (fork()=-1) then … else … :

    main()
{
switch (fork())
{
case 0 :

printf("\n Created pid %d with ppid %d \n", getpid(), getppid());

exit(0);
case -1 :

exit(1);
default :

printf(" Current pid is %d with ppid %d \n", getpid(), getppid());

exit(0);
}
}

Эта маленькая программка создает один
новый процесс. Функции getpid() и getppid() просто-напросто
выдают PID и PPID текущего процесса. Сюда я их
включил, чтобы ты убедился: порожденный
процесс имеет Parent PID, равный PID’у процесса
изначального, порождающего процесса (т.е.
программы). Что и требовалось доказать ;-). 
Сказали о порождении процессов, теперь
логично было бы рассказать об их убийстве.
Занимается этим зловещая функция kill (какое
оригинальное название 8-). Синтаксис ее
таков:

kill (pid_t pid_number, SIGKILL);

Первое — номер процесса (берется в программе,
как ей надобно, в соответствии с задачей,
или вводится ручками как переменная спец.
типа pid_t), второе — посылаемый ему сигнал.
Надо сказать, что функция kill, не смотря на
свое очевидное название,
многофункциональна, и SIGKILL — всего лишь один
из возможных передаваемых процессу
сигналов (в данном случае — это сигнал
процессу умереть 8-), их все мы тут
рассматривать не будем. Очевидно, кусок
кода в проге, отвечающий за убийство
указываемых тобою процессов, будет
примерно таков:

pid_t gpid;
printf("Input PID to kill\n");
scanf("%d",&gpid);
kill (gpid, SIGKILL);

Ты
вводишь ручками номер приговоренного
процесса, и он тихо умирает, будучи не в
силах сопротивляться функции
kill
;-).

Итак,
про рождение мы узнали, про убийство – тоже,
осталось собрать все воедино и наваять
прогу, которая бы создавала любое,
указанное тобой кол-во процессов, а затем
любой же из них (или сразу все вместе)
убивала.

Прога
получается наилементарнейшая, главную
функцию ее я реализовал опять-таки через
switch,
просто потому, что конструкция получается
очень понятная и стройная, легкая к чтению.

Заставляем функцию fork
возвращать PID
созданного процесса, это понадобится для
главной функции. Для того, чтобы создавать
не один процесс, а сколько душе угодно,
стряпаем массивчик, куда будем пихать
созданные fork’ом
PID’ы
процессов (вот для чего нужно требовать от fork
их возвращения), кол-во элементов массива,
разумеется, задаем сами – сколько их будет,
столько раз функцию fork
и вызовем, столько процессов породим.
Убийство реализуем как в виде возможности
прикончить отдельно взятый процесс (по его PID’у),
так и возможности  грохнуть
все сразу. Вот, вроде, и все, по сорцу
разберешься.

Процессы-то мы создаем, а
вот что они делают — непонятно. Позже ты
научишься управлять ими, заставляя
выполнять определенное действие. Ведь
работа с процессами — одна из самых мощных
сторон OS UNIX.

Исходники

Оставить мнение

Check Also

Что можно сделать с iPhone, зная пасскод. Как сливают данные, уводят iCloud и блокируют остальные устройства

Последние несколько месяцев мы много писали о нововведениях в iOS 11. «Теперь-то заживем!»…