10.10 alarm以及pause函数

#include <unistd.h>
unsigned int alarm(unsigned int seconds);
    Returns:0 or number of seconds until previously set alarm.

seconds的数值指定了未来信号生成所需要的秒数，当事件到达，信号就会被内核生成，虽然在进程获得控制权开始处理信号之前会因为处理器调度而多花一些额外的时间。

早期版本的UNIX系统实现可以允许信号被提前1秒中发送，但是POSIX.1并不允许这种行为。

#include <unistd.h>
int pause(void);
    Returns:-1 with errno set to EINTR

pause返回的唯一的时间是一个信号处理函数被调用，然后该信号处理函数返回，在这种情况下，pause将返回-1，并且将errno设置为EINTR.

Example

使用函数alarm以及pause,我们可以将一个进程放到睡眠状态一段指定的时间，函数sleep1就是为了达成这一目的，但是正如后面将会看到的，该函数有一个问题.

#include <signal.h>
#include <unistd.h>
static void sig_alrm(int signo)
{
        /*nothing to do ,just return to wake up the pause*/
}
unsigned int sleep1(unsigned int seconds)
{
        if(signal(SIGALRM, sig_alrm) == SIG_ERR)
        {
                return (seconds);
        }
        alarm(seconds); /*start the timer*/
        pause();        /*next caught signal wakes us up*/
        return(alarm(0));/*turn off timer,return unslept time*/
}

该函数看起来与函数sleep差不多，但是这个简单的实现有三个问题:

Example

SVR2实现中的sleep函数使用了函数setjmp以及longjmp来避免上面提到的竞态条件的出现，该函数的一个简单版本，称为sleep2,如图10.8中显示的那样，(为了减小该函数的尺寸，我们并没有解决上述提到的问题1以及问题2).

#include <setjmp.h>
#include <signal.h>
#include <unistd.h>
static jmp_buf env_alrm;
static void sig_alrm(int signo)
{
        longjmp(env_alrm, 1);
}
unsigned int sleep2(unsigned int seconds)
{
        if(signal(SIGALRM, sig_alrm) == SIG_ERR)
                return (seconds);
        if(setjmp(env_alrm) == 0)
        {
                alarm(seconds);         /*start the timer*/
                pause();                /*next caught signal wake us up*/
        }
        return (alarm(0));              /*turn off timer,return unslept time*/
}

Figure 10.8 Another (imperfect )implementation of sleep

函数sleep2避免了图10.7中的竞态条件问题，即使pause函数从来没有被执行过，当SIGALRM信号出现的时候，sleep2总是会成功返回。

然而，当我们涉及到与其他信号进行交互的时候，sleep2就会出现一个微妙的错误:如果SIGALRM中断了一些其他信号处理函数，然后当我们执行函数longjmp的时候，我们就会终止掉其他的信号处理函数，图10.9显示了这样的一个场景，在SIGINT处理函数中有一个循环，该循环保证了系统需要执行该函数5S以上，我们的目标是时期执行时间超过sleep2的参数，整形变量k被声明为volatile，是为了防止编译器优化的时候丢弃这个循环。

#include "apue.h"
unsigned int sleep2(unsigned int);
static void sig_int(int);
int main(void)
{
        unsigned int unslept;
        if(signal(SIGINT, sig_int) == SIG_ERR)
        {
                err_sys("signal(SIGINT) error");
        }
        unslept = sleep2(5);
        printf("sleep2 returned:%u\n", unslept);
        exit(0);
}
static void sig_int(int signo)
{
        int i,j;
        volatile int k;
        /*
         * Tune these loops to run for more than 5 seconds
         * on wahtever system this test program is run.
         *
         */
        printf("\nsig_int starting\n");
        for(i = 0; i < 300000; i++)
                for(j = 0; j < 4000; j++)
                        k += i * j;
        printf("sig_int finished\n");
}

当我们在执行10_9所示的程序的时候，按下终端字符来中断睡眠状态的进程，我们将得到如下的输出:

os@debian:~/UnixProgram/Chapter10$ ./10_9.exe
^C
sig_int starting
sleep2 returned:0
os@debian:~/UnixProgram/Chapter10$ 

我们可以看出sleep2中的longjmp函数会终止其他的信号处理函数sig_int,即是其他的信号处理函数还没有完成，如果你将SVR2的sleep函数与其他的信号处理函数混合使用的话，就会遇到这样的问题，详见练习10.3

#include "apue.h"
static void sig_alrm(int);
int main(void)
{
        int     n;
        char    line[MAXLINE];
        if(signal(SIGALRM, sig_alrm) == SIG_ERR)
        {
                err_sys("signal(SIGALRM) error");
        }
        alarm(10);
        if((n = read(STDIN_FILENO,line, MAXLINE)) < 0)
        {
                err_sys("read error");
        }
        alarm(0);
        write(STDOUT_FILENO, line, n);
        exit(0);
}
static void sig_alrm(int signo)
{
        /*nothing to do,just return to interrupt the read*/
}

Figure10.10 Calling read with a timeout
上述代码的处理序列在UNIX应用程序中是常见的，但是该应用程序有两个问题:

1. 与图10.7中的例子相同的缺陷:在对函数alarm以及函数read的调用之间出现了一个竞态条件，如果进程在这两个函数的调用之间阻塞了进程，并且阻塞的时间超过了定时器时长，那么read函数就可能永远被阻塞了，许多这种类型的操作都会使用一个很长的定时器，比如说一分钟或者更长，使得上述情况的发生变得不太可能，然而无论如何，这仍然是一个竞态条件。
2. 如果系统调用是自动重启的，那么read函数在SIGALRM信号处理函数返回以后并不会被中断，在这种情况下，超时将起不到任何作用。

include "apue.h"
#include <setjmp.h>
static void sig_alrm(int);
static jmp_buf env_alrm;
int main(void)
{
        int     n;
        char    line[MAXLINE];
        if(signal(SIGALRM, sig_alrm) == SIG_ERR)
        {
                err_sys("signal(SIGALRM) error");
        }
        if(setjmp(env_alrm) != 0)
                err_quit("read timeout");
        alarm(10);
        if((n = read(STDIN_FILENO, line, MAXLINE)) < 0)
        {
                err_sys("read error");
        }
        alarm(0);
        write(STDOUT_FILENO, line, n);
        exit(0);
}
static void sig_alrm(int signo)
{
        longjmp(env_alrm, 1);
}

Figure 10.11 Calling read with a timeout, using longjmp.