QNX/UNIX: Анатомия параллелизма

#include <signal.h>
#include <unistd.h>
// обработчик сигнала SIGINT
static void handler(int signo) {
 // восстановить обработчик:
 signal(SIGINT, handler);
 cout << 'Получен сигнал SYSINT' << endl;
}
int main() {
 // устанавливаются диспозиции сигналов:
 signal(SIGINT, handler);
 signal(SIGSEGV, SIG_DFL);
 signal(SIGTERM, SIG_IGN);
 while(true) pause();
}

Примечание

Макросы SIG_DFL и SIG_IGN определяются так:

#define SIG_ERR  (( void(*)(_SIG_ARGS))-1 )
#define SIG_DFL  (( void(*)(_SIG_ARGS))0)
#define SIG_IGN  (( void(*)(_SIG_ARGS))1)
#define SIG_HOLD (( void(*)(_SIG_ARGS))2)

где _SIG_ARGS — это фактически тип int. SIG_DFL и SIG_IGN устанавливают диспозиции сигнала «по умолчанию» и «игнорировать» соответственно, а о SIG_HOLD мы будем отдельно говорить позже.

Выполнение этой программы вам будет не так просто прекратить: на комбинацию завершения [Ctrl +C] она отвечает сообщением о получении сигнала... и все. Воспользуемся для этого посылкой программе опять же сигнала, но из другого процесса (другого экземпляра командного интерпретатора). Смотрим PID запущенного процесса:

# pidin
...
220//86 1 /s2 10 r STOPPED
...

И посылаем процессу сигнал завершения:

# kill -9 2207786 или kill -SIGKILL 2207786

Таким же образом, как показано командой kill, мы будем посылать сигналы процессам «извне» и в описываемых далее тестах, не останавливаясь подробно, как это происходит, в том числе и для сигналов реального времени (41…56).

Предыдущий пример можно переписать (файл s4.cc) для обеспечения часто требуемой на практике защиты от немедленного прерывания выполнения по [Ctrl+C], чтобы дать программе возможность выполнить все требуемые операции по завершению (сбросить буферы данных на диск, закрыть файлы, сокеты и другие используемые объекты):

#include <stdlib.h>
#include <iostream.h>
#include <signal.h>
#include <unistd.h>
static void handler(int signo) {
 cout << 'Saving data ... wait.
' << flush;
 sleep(2); // здесь выполняются все завершающие действия!
 cout << '                          ' << flush;
 exit(EXIT_SUCCESS);
}
int main() {
 signal(SIGINT, handler);
 signal(SIGSEGV, SIG_DFL);
 signal(SIGTERM, SIG_IGN);
 while (true) pause();
}

Оператор ожидания pause() при поступлении сигналов завершается с возвратом -1, а переменная errno устанавливается в EINTR. Этот оператор дает нам еще один способ (файл s3.cc) неявного (без явной установки обработчиков) использования сигналов:

#include <stream.h>
#include <stdlib.h>
#include <unistd.h>
int main(void) {
 alarm(5);
 cout << 'Waiting to die in 5 seconds ...' << endl;
 pause();
 return EXIT_SUCCESS;
}

Описываемая модель обработки сигналов обладает рядом недостатков, считается устаревшей и, более того, как было показано, не обеспечивает надежную обработку сигналов. Тем не менее эту модель достаточно широко применяют в простых случаях, например при необходимости установить тайм-аут для некоторой операции. Вот как, к примеру, устанавливается тайм-аут ожидания установления соединения в TCP/IP-клиенте [9]:

void alarm_handler(int sig) { return; }
int main() {
 ...
 signal(SIGALRM, alarm_handler); alarm(5);
 int rc = connect( ... );
 alarm(0);
 if (rc < 0 && errno == EINTR)
 cout << 'Истек тайм-аут' << endl, exit(EXIT_FAILURE);
 ...
}

Здесь уместно напомнить немаловажное обстоятельство, связанное с сигналами, которое обделяется вниманием во многих руководствах по программированию: большинство блокирующих вызовов API (connect(), delay(), wait(), waitid() и многие другие) будут разблокированы при получении блокированным потоком любого сигнала. Такие вызовы API, как pause() и sigwait(), вообще предназначены только для выполнения пассивной блокировки до момента поступления сигнала. Многие их них возвращают значение