LINUX下模拟实现sleep函数

95 阅读 0 评论 63 点赞

我是靠谱客的博主粗犷大侠，这篇文章主要介绍LINUX下模拟实现sleep函数，现在分享给大家，希望可以做个参考。

LINUX下模拟实现sleep函数

1.普通版本的mysleep函数

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 1 #include
    
    
     
     
  2 #include
     
     
      
      
  3 #include
      
      
       
       
  4 
  5 void myhandler(int sig)
  6 {
  7 
  8 }
  9 
 10 int mysleep(int timeout)
 11 {
 12     struct sigaction act,oact;
 13     act.sa_handler=myhandler;
 14     act.sa_flags=0;
 15     sigemptyset(&act.sa_mask);
 16     sigaction(SIGALRM,&act,&oact);
 17 
 18     alarm(timeout);
 19     pause();
 20     int ret=alarm(0);
 21     sigaction(SIGALRM,&oact,NULL);
 22     return ret;
 23 }
 24 
 25 int main()
 26 {
 27     while(1)
 28     {
 29         mysleep(3);
 30         printf("using mysleep!n");
 31     }
 32     return 0;
 33 }

2. 相关函数介绍

（1）alarm函数

#include<unistd.h>

unsigned int alarm(unsigned int seconds)

alarm也称为闹钟函数。它可以在进程中设置一个定时器，当定时器指定的时间到时，它向进程发送SIGALRM信号。如果忽略或者不捕获此信号，则其默认动作是终止调用该alarm函数的进程。

返回值：是0或者是以前设定的闹钟时间剩余的秒数。

如果seconds值为0,表示取消以前设定的闹钟,函数的返回值仍然是以前设定的闹钟时间还余下的秒数。

（2）sigaction

#include <signal.h>

int sigaction(int signo,const struct sigaction *act,struct sigaction *oact);

sigaction函数可以读取和修改与指定信号相关联的处理动作。

返回值：调用成功返回0；出错则返回-1.

signal是指定信号的编号。若act指针非空，则根据act修改该信号的处理动作。若oact指针非空，则通过oact创出该信号原来的处理动作；act和oact指向sigaction结构体。

将sa_handler赋值为常数SIG_IGN传给sigaction表示忽略信号；赋值为常数SIG_DFL表示执行系统默认动作,赋值为一个函数指针表示用自定义函数捕捉信号。向内核注册了一个信号处理函数,该函数返回值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信号。显然,这也是一个回调函数,不是被main函数调用,而是被系统所调用。

sa_mask：进程的信号屏蔽字。如果在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,则用sa_mask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时自动恢复原来的信号屏蔽字。

sa_flags：sa_flags字段包含一些选项,本文代码把sa_flags设为0。

sa_sigaction是实时信号的处理函数。

(3)pause

#include <unistd.h>

int pause(void);

pause函数使调用进程挂起直到有信号递达。

如果信号的处理动作是终止进程，则进程终止，pause函数没有机会返回；

如果信号的处理动作是捕捉，则调用了信号处理函数之后pause返回-1，error设置为EINTR，所以pause只有出错的返回值。错误码EINTR表示“被信号中断"。

3.竞态条件

在普通版本的mysleep程序中，我们设想的时序是

（1）注册SIGALRM信号的处理函数；

（2）调用alarm(n)设定闹钟；

（3）内核调度优先级更高的进程取代当前进程执行，并且优先级更高的进程有很多个，每个都要执行很长时间

（4）n秒钟之后闹钟超时了，内核发送SIGALRM信号给这个进程，处于未决状态；

（5）优先级更高的进程执行完，内核要调度回这个进程继续执行。SIGALRM信号递达，执行处理函数后再次进入内核；

（6）返回这个进程的主控制流程，alarm(n)返回，调用pause()挂起等待。

由于系统运行代码时并不会按照我们的思路走，虽然alarm(timeout)紧接着的下一行就是pause(),但是无法保证pause()一定会在调用alarm(timeout)之后的timeout秒之内被调用。

由于异步事件在任何时候都有可能发生,如果写程序时考虑不周密,就可能由于时序问题而导致错误。

由于时序问题而导致的错误，叫做竞态条件

只有将“解除信号屏蔽”和“挂起等待信号”两步合并成一个原子操作，才能避免由于竞态条件带来的错误。

sigsuspend函数正好可以完成这个功能。sigsuspend包含了pause的挂起等待功能，同时解决了竞态条件。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include
   
   
    
    
#include
    
    
     
     
#include
     
     
      
      
void myhandler(int sig)
{}

int mysleep(int timeout)
{
     struct sigaction act,oact;
     sigset_t mask,omask,suspmask;
     unsigned int unslept;
     act.sa_handler=myhandler;
     act.sa_flags=0;
     sigemptyset(&act.sa_mask);
     sigaction(SIGALRM,&act,&oact);
     sigemptyset(&mask);
     sigaddset(&mask,SIGALRM);
     sigprocmask(SIG_BLOCK,&mask,&omask);
     alarm(timeout);
     suspmask=omask;
     sigdelset(&suspmask,SIGALRM);
     sigsuspend(&suspmask);
     int ret=alarm(0);
     sigaction(SIGALRM,&oact,NULL);
     sigprocmask(SIG_SETMASK,&omask,NULL);
     return ret;
}

int main()
 {
     while(1)
    {
        mysleep(3);
       printf("using mysleep!n");
    }
    return 0;
 }