Concept

  1. 概念
    1. 信号是软件中断
    2. 信号的响应依赖于中断
  2. signal()
    • void (*signal)(int) signal(int signum, void (*func)(int))
    • 信号会打断阻塞的系统调用
  3. . 信号的不可靠（信号的行为不可靠）
  4. 可重入函数
    • 所有的系统调用都是可重入的，一部分库函数也是可重入的，如：memcpy。不可重入的函数有可能有_r版本，来做到可重入
  5. 信号的响应过程
    内核会给每个进程维护两个向量表（mask和pending），每当进程从kernel态到user态，会对两个向量表进行与运算，对应位置上的mask&pending如果为1，那么进程将响应对应的信号。此时内核会将二者均置位0，当响应完毕后，回到内核，恢复对应位置的mask为1（这样的做法是为了防止重入现象），当下一次回到user态，系统将继续原来正常的流程
    1. 如何忽略掉一个信号？
      • 把对应信号的mask位置为0，即信号屏蔽操作
    2. 标准信号为什么要丢失？
      • 因为是位图，当程序再执行注册signal动作函数的过程中，再来了一万个信号，也是仅仅置1，下一次从kernel到user只会执行一次signal动作，故此时到来的其他9999个信号相当于会被丢弃
    3. 标准信号的缺陷：标准信号没有一个严格的顺序
    • 信号从收到到响应有一个不可避免的延迟
  6. 常用函数
    • kill (int pid, int sig)
    • raise (int sig) 给自己发送一个信号，如 进程的kill和线程的pthread_kill
    • alarm (unsigned int seconds)
      • 多个谁放到后面谁有作用，所以不能作为多任务计时器
    • setitimer ()
      • 例：使用单一计时器，构造一组函数，实现任意数量计时器
    • pause (void) 等待一个信号来打断
    • system
    • sleep

volatile不轻信内存中存储的数值，去真实的地址拿数值 

  1. // 使用signal和alarm，完成五秒中内的计数
  2. #include <unistd.h>
  3. #include <stdio.h>
  4. #include <time.h>
  5. #include <signal.h>
  6. #include <sys/types.h>
  8. static int jug = 0;
  10. static void alrm_handler(int arg) {
  11.     jug = 1;
  12. }
  14. int main() {
  16.     int64_t count = 0;
  18.     signal(SIGALRM, alrm_handler);
  19.     alarm(5);
  21.     while (jug != 1) {
  22.         count++;
  23.     }
  24.     printf("%lld\n", count);
  26.     return 0;
  27. }
  29. // 但是如果开启O2优化，即会优化上述while中jug的指令，导致死循环
  30. // 所以必须给jug使用volatile，让程序去真实地址取数据，减去这一块的优化
  1. 信号集
  2. 信号屏蔽字/pending集处理
  3. 扩展
    • sigsuspend
    • sigaction
    • setitimer
  4. 实时信号

Exercise

  1. 慢速cat
    • 使用volatile、判断read打开是否为真、signal和alarm延时
    • 漏桶模型
  1. #include <fcntl.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <sys/types.h>
  5. #include <errno.h>
  6. #include <sys/stat.h>
  7. #include <signal.h>
  9. #define CPS     10
  10. #define BUFSIZE CPS
  12. static volatile int loop = 0;
  14. void alrm_handler(int arg) {
  15.         alarm(1);
  16.         loop = 1;
  17. }
  19. int main(int argc, char **argv) {
  21.         int sfd, dfd = 1;
  22.         char buf[BUFSIZE];
  23.         int len, ret, pos;
  25.         if (2 > argc) {
  26.                 fprintf(stderr, "Too less arguments\n");
  27.                 exit(0);
  28.         }
  30.         signal(SIGALRM, alrm_handler);
  31.         alarm(1);
  33.         do {
  34.                 sfd = open(argv[1], O_RDONLY);
  35.                 if (!sfd) {
  36.                         if (errno != EINTR) {
  37.                                 perror("open\n");
  38.                                 exit(1);
  39.                         }
  40.                 }
  41.         } while(sfd < 0);
  43.         while (1) {
  44.                 while (!loop)
  45.                         pause();
  46.                 loop = 0;
  48.                 while ((len = read(sfd, buf, BUFSIZE)) < 0) {
  49.                         if (len < 0) {
  50.                                 if (errno == EINTR) {
  51.                                         continue;
  52.                                 }
  53.                                 perror("read\n");
  54.                                 break;
  55.                         }
  56.                 }
  57.                 pos = 0;
  58.                 if (len == 0)
  59.                         break;
  60.                 while (len > 0) {
  61.                         ret = write(dfd, buf + pos, len);
  62.                         if (ret < 0) {
  63.                                 if (errno == EINTR) {
  64.                                         continue;
  65.                                 }
  66.                                 perror("write\n");
  67.                                 exit(1);
  68.                         }
  69.                         pos += ret;
  70.                         len -= ret;
  71.                 }
  72.         }
  74.         close(sfd);
  76.         return 0;
  77. }
  • 令牌桶模型
    • 随着时间令牌积累，我们能够单次读取的流量越大
    • 存在令牌上限
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <signal.h>
  4. #include <errno.h>
  5. #include <fcntl.h>
  6. #include <stdint.h>
  7. #include <unistd.h>
  9. #define MAX_TOKEN 100
  10. #define TOKEN_GAP 10
  11. #define BUFSIZE 20
  12. #define TIME_GAP 1
  14. static int token = 0;
  15. volatile static int loop = 1;
  17. static void tkAlarm(int arg) {
  18.     token += TOKEN_GAP;
  19.     if (token >= MAX_TOKEN) {
  20.         token = MAX_TOKEN;
  21.     }
  22.     alarm(TIME_GAP);
  23.     loop = 0;
  24. }
  26. int main(int argc, char **argv)
  27. {
  28.     if (argc < 2) {
  29.         printf("Given arguments are less than 2\n");
  30.         goto err;
  31.     }
  33.     int sfd = 0, dfd = 0;
  34.     int len = 0, pos = 0, ret = 0;
  35.     uint8_t buf[MAX_TOKEN * BUFSIZE] = {0};
  37.     do {
  38.         sfd = open(argv[1], O_RDONLY);
  39.         if (sfd <= 0) {
  40.             if (errno != EINTR) {
  41.                 perror("open");
  42.                 exit(-1);
  43.             }
  44.         }
  45.     } while(sfd <= 0);
  46.     dup2(dfd, STDOUT_FILENO);
  48.     signal(SIGALRM, tkAlarm);
  49.     alarm(TIME_GAP);
  51.     while (1) {
  52.         while (loop)
  53.             pause();
  54.         loop = 1;
  56.         while ((len = read(sfd, buf, token * BUFSIZE)) < 0) {
  57.             if (len < 0) {
  58.                 if (errno != EINTR) {
  59.                     perror("read");
  60.                     exit(-1);
  61.                 }
  62.             }
  63.         }
  64.         pos = 0;
  65.         if (len == 0)
  66.             break;
  68.         while (len > 0) {
  69.             ret = write(dfd, buf + pos, len);
  70.             if (ret < 0) {
  71.                 if (errno == EINTR) {
  72.                     continue;
  73.                 }
  74.                 perror("write");
  75.                 exit(-1);
  76.             }
  77.             pos += ret;
  78.             len -= ret;
  79.         }
  80.     }
  82.     close(sfd);
  83. err:
  84.     return 0;
  85. }
  • setitimer ```c

    include

    include

    include

    include

    include

    include

    include

    include

define MAX_TOKEN 100

define TOKEN_GAP 10

define BUFSIZE 20

define TIME_GAP 1

static int token = 0; volatile static int loop = 1; static struct itimerval itv;

static void tkAlarm(int arg) { token += TOKEN_GAP; if (token >= MAX_TOKEN) { token = MAX_TOKEN; } loop = 0; }

void itvInit() { itv.it_interval.tv_sec = 1; itv.it_interval.tv_usec = 0; itv.it_value.tv_sec = 1; itv.it_value.tv_usec = 0; }

int main(int argc, char **argv) { if (argc < 2) { printf(“Given arguments are less than 2\n”); goto err; }

  1. int sfd = 0, dfd = 0;
  2. int len = 0, pos = 0, ret = 0;
  3. uint8_t buf[MAX_TOKEN * BUFSIZE] = {0};
  5. do {
  6.     sfd = open(argv[1], O_RDONLY);
  7.     if (sfd <= 0) {
  8.         if (errno != EINTR) {
  9.             perror("open");
  10.             exit(-1);
  11.         }
  12.     }
  13. } while(sfd <= 0);
  14. dup2(dfd, STDOUT_FILENO);
  16. signal(SIGALRM, tkAlarm);
  17. itvInit();
  18. if (setitimer(ITIMER_REAL, &itv, NULL) < 0) {
  19.     perror("setitimer");
  20.     exit(-1);
  21. }
  23. while (1) {
  24.     while (loop)
  25.         pause();
  26.     loop = 1;
  28.     while ((len = read(sfd, buf, token * BUFSIZE)) < 0) {
  29.         if (len < 0) {
  30.             if (errno != EINTR) {
  31.                 perror("read");
  32.                 exit(-1);
  33.             }
  34.         }
  35.     }
  36.     pos = 0;
  37.     if (len == 0)
  38.         break;
  40.     while (len > 0) {
  41.         ret = write(dfd, buf + pos, len);
  42.         if (ret < 0) {
  43.             if (errno == EINTR) {
  44.                 continue;
  45.             }
  46.             perror("write");
  47.             exit(-1);
  48.         }
  49.         pos += ret;
  50.         len -= ret;
  51.     }
  52. }
  54. close(sfd);

err: return 0; }

```

Projects

Ref

[1] C/C++学习路线图—Linux高并发服务器开发