Михаил Шохирев - Язык программирования Perl
Выполнение всей программы заканчивается, когда заканчивается последний порожденный процесс. Ожидание окончания выполнения всех дочерних процессов можно организовать с помощью функции wait(), которая возвращает PID завершившегося подпроцесса и -1, если все процессы-потомки завершили работу.
В Perl есть несколько способов организации взаимодействия процессов при их параллельном выполнении. Один из них - создать программный канал (pipe), который представляет из себя два файловых манипулятора - приемник (reader) и передатчик (writer) - связанных таким образом, что записанные в передатчик данные могут быть прочитаны из приемника. Программный канал создается с помощью функции pipe(), которой передаются имена двух файловых манипуляторов: приемника и источника. Один из вариантов взаимодействия процессов через программный канал показан в следующем примере:
use IO::Handle; # подключаем стандартный модуль pipe(READER, WRITER); # создаем программный канал WRITER->autoflush(1); # включаем авто-очистку буфера if ($pid = fork()) { # процесс-предок получает PID потомка close READER; # предок не будет читать из канала print WRITER "Послано предком (PID $$):n"; for (my $n = 1; $n <= 5; $n++) { # запись в передатчик print WRITER "$n "; } close WRITER; # закрываем канал и waitpid $pid, 0; # ждем завершения потомка } die "fork не отработал: $!" unless defined $pid; if (!$pid) { # процесс-потомок получает 0 close WRITER; # предок не будет писать в канал print "Потомок (PID $$) прочитал:n"; while (my $line = <READER>) { # чтение из приемника print "$line"; } close READER; # канал закрывается exit; # потомок завершает работу }
Во время выполнения этого примера в стандартный выходной поток будет выведено следующее:
Потомок (PID -2032) прочитал: Послано предком (PID 372): 1 2 3 4 5
Если нужно организовать передачу данных в обратном направлении, организуется канал, в котором передатчик будет в процессе-потомке, а приемник - в процессе-предке. Так как с помощью программного канала можно передавать данные только в одном направлении, то при необходимости двустороннего обмена данными между процессами создаются два программных канала на передачу в обоих направлениях.
Кроме программных каналов, процессы могут обмениваться информацией и другими способами: через именованные каналы (FIFO) и разделяемые области памяти, если они поддерживаются операционной системой, с помощью сокетов (что будет рассмотрено в следующей лекции) и при помощи сигналов.
В операционных системах имеется механизм, который может доставлять процессу уведомление о наступлении какого-либо события. Этот механизм основан на так называемых сигналах. Работа с ними происходит следующим образом. В программе может быть определен обработчик того или иного сигнала, который автоматически вызывается, когда ОС доставляет сигнал процессу. Сигналы могут отправляться операционной системой, или один процесс может с помощью ОС послать сигнал другому. Процесс, получивший сигнал, сам решает, каким образом реагировать на него, - например, он может проигнорировать сигнал. Перечень сигналов, получение которых можно попытаться обработать, находится в специальном хэше с именем %SIG. Поэтому допустимые идентификаторы сигналов можно вывести функцией keys(%SIG). Общеизвестный пример - сигнал прерывания выполнения программы INT, который посылает программе операционная система по нажатию на консоли сочетания клавиш Ctrl+C. Как устанавливать обработчик конкретного сигнала, показано на примере обработки сигнала INT:
# устанавливаем обработчик сигнала INT $SIG{INT} = &sig_handler; # ссылка на подпрограмму # начало основной программы print "Работаю в поте лица...n" while (1); # бесконечный цикл sub sig_handler { # подпрограмма-обработчик сигнала $SIG{INT} = &sig_handler; # переустанавливаем обработчик print "Получен сигнал INT по нажатию Ctrl+Cn"; print "Заканчиваю работу!n"; exit; # завершение выполнения программы }
Выполнение примера сопровождается выводом сообщений, подтверждающих обработку поступившего сигнала:
Работаю в поте лица... Получен сигнал INT по нажатию Ctrl+C Заканчиваю работу!
Примером реальной программы, выполняющейся в бесконечном цикле, может служить любой сервер, ожидающий запросов от клиентских программ и перечитывающий свой конфигурационный файл после получения определенного сигнала (обычно HUP или USR1). Если необходимо временно игнорировать какой-то сигнал, то соответствующему элементу хэша %SIG присваивается строка 'IGNORE'. Восстановить стандартную обработку сигнала можно, присвоив соответствующему элементу %SIG строку 'DEFAULT'.
Процесс может посылать сигналы самому себе, например, для отслеживания окончания запланированного периода времени (для обработки тайм-аута). В приведенном примере длительная операция прерывается по истечении указанного промежутка времени:
# устанавливаем обработчик сигнала ALRM (будильник) $SIG{ALRM} = sub { die "Timeout"; }; # анонимная подпрограмма $timeout = 3600; # определяем величину тайм-аута (сек.) eval { # блок обработки возможной ошибки alarm($timeout); # устанавливаем время отправки сигнала # некая длительная операция: print "Работаю в поте лица...n" while (1); alarm(0); # нормальное завершение операции }; # в специальной переменной [email protected] - сообщение об ошибке if ([email protected] =~ /Timeout/) { # проверяем причину ошибки print "Аварийный выход по истечении времени!"; }
Отправка сигнала одним процессом другому также используется в качестве средства взаимодействия процессов. Сигнал отправляется процессу с помощью функции kill(), которой передаются два аргумента: номер сигнала и PID процесса. Схему реагирования порожденного процесса на сигналы, получаемые от процесса-предка, можно увидеть на следующем учебном примере:
my $parent = $$; # PID родительского процесса my $pid = fork(); # 'разветвить' текущий процесс # fork вернет PID потомка в процессе-предке и 0 в потомке die "fork не отработал: $!" unless defined $pid; if ($pid) { # ---------- родительский процесс ---------- print "Начался предок PID $$n"; for (1..3) { print "Предок PID $$ работает $_n"; print "Предок PID $$ отправил сигналn"; kill HUP, $pid; sleep 2; # 'заснуть' на 2 секунды } print "Закончился предок (PID $$)n"; } unless ($pid) { # ---------- дочерний процесс ---------- my $counter = 0; # счетчик полученных сигналов $SIG{HUP} = sub { ### обработчик сигнала ### $counter++; print "tПотомок получил $counter-й сигнал!n"; }; ### конец обработчика сигнала ### print "tНачался потомок PID $$ предка $parentn"; for (1..7) { print "tПотомок PID $$ работает $_n"; sleep 1; # 'заснуть' на 1 секунду } print "tЗакончился потомок PID $$n"; }
Поведение этих процессов во время выполнения программы можно проследить по выводимым ими сообщениям:
Начался потомок PID -800 предка 696 Потомок PID -800 работает 1 Начался предок PID 696 Предок PID 696 работает 1 Предок PID 696 отправил сигнал Потомок получил 1-й сигнал! Потомок PID -800 работает 2 Предок PID 696 работает 2 Предок PID 696 отправил сигнал Потомок PID -800 работает 3 Потомок получил 2-й сигнал! Потомок PID -800 работает 4 Предок PID 696 работает 3 Предок PID 696 отправил сигнал Потомок PID -800 работает 5 Потомок получил 3-й сигнал! Потомок PID -800 работает 6 Закончился предок (PID 696) Потомок PID -800 работает 7 Закончился потомок PID -800
Сигналы нельзя считать слишком надежным и информативным средством обмена информацией: для передачи данных лучше использовать другие способы. Зато можно проверить состояние дочернего процесса, отправив ему особый нулевой сигнал функцией kill(0, $pid). Этот вызов не влияет на выполнение процесса-потомка, но возвращает истину (1), если процесс "жив", и ложь (0), если он завершился или ему нельзя посылать сигналы. Одинаковая реакция на нулевой сигнал гарантируется на различных платформах. Кроме того, можно прекратить выполнение дочернего процесса, отправив ему сигнал KILL вызовом kill(KILL, $pid).
В последних версиях Perl появилась еще одна модель многозадачности - легковесные процессы (light-weight processes), называемые также потоками управления или нитями. (По-английски фраза "Perl threads" звучит как каламбур и может быть переведена как "нитки жемчуга" или "жемчужные ожерелья"). Нити отличаются от полновесных процессов с независимыми ресурсами тем, что выполняются в рамках одного процесса в единой области памяти. Поэтому создание нити происходит быстрее запуска отдельного процесса и требует меньше ресурсов операционной системы. Выполнение нитей в одной области памяти позволяет эффективно организовать совместный доступ к разделяемым данным. Кроме того, программист получает более полный контроль над параллельно выполняющимися потоками управления. Принципиальное различие между полновесными процессами, созданными операционной системой, и многопоточными нитями показано на рис. 16.1.
Рис. 16.1. Полновесные процессы и нити (потоки управления)
