C++linux高并发服务器项目实践 day8

内存映射
- 内存映射相关系统调用
- 例子
- 思考问题
- 案例2
- 案例3
信号
- 信号的5中默认处理动作
- 信号相关函数
- - kill、raise和abort函数
  - alarm函数
  - - 案例
  - setitimer函数
- signal信号捕捉函数

内存映射

内存映射是将磁盘文件的数据映射到内存，用户通过修改内存就能修改磁盘文件
在这里插入图片描述

内存映射相关系统调用

#include <sys/mman.h>
void *mmap(void *addr,size_t length,int prot,int flags,int fd,off_t offset);
int munmap(void *addr ,size_t length);

#include <sys/mman.h>
void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);

功能:将一个文件或者设备的数据映射到内存中
参数:
- void *addr:映射内存的首地址，NULL，由内核指定
- length:要映射的数据的长度这个值不能为0.建议使用文件的长度
  获取文件的长度:sta lseek
- prot:对申请的内存映射去的操作权限
  - PROT_EXEC:可执行的权限
  - PROT_READ:可读的权限
  - PROT_WRITE:写权限
  - PROT_NONE:没有权限
    要操作映射内存，必须要有读的权限。
    一般是PROT_READ或者PROT_READ|PROT_WRITE
- flags:
  - MAP_SHARED : 映射群的数据会自动和磁盘文件进行同步，进程间通信，必须要设置这个选项
  - MAP_PRIVATE: 不同步，内存映射去的数据改变了，对原来的文件不会修改，会重新创建一个新的文件(copy on write)
- fd:需要映射的文件的文件描述符
  - 通过open得到，open的是一个磁盘文件
  - 注意:文件的大小不能为0、open指定的权限不能和prot参数有冲突
    prot:PROT_READ open:只读/读写
    prot:PROT_READ | PROT_WRITE open:读写
- offset:偏移量，一般不用。必须指定的是4k的整数倍，0表示不偏移
返回值:返回创建的内存的首地址
失败返回MAP_FAILED,(void *)-1

int munmap(void *addr, size_t length);

功能:释放内存映射
参数:
- addr : 要释放的内存的首地址
- length : 要释放的内存的大小,要和mmap函数中的length参数的值一样

例子

使用内存映射实现进程间通信:

有关系的进程(父子进程)
- 还没有子进程的时候
  - 通过唯一的父进程，先创建内存映射区
- 有了内存映射区以后，创建子进程
- 父子进程共享创建内存映射区
没有关系的进程间通信
- 准备一个大小不是0的磁盘文件
- 进程1 通过磁盘文件创建内存映射区
  - 得到一个操作这块内存的指针
- 进程2 通过磁盘文件创建内存映射区
  - 得到一个操作这块内存的指针
- 使用内存映射区通信

注意:内存映射区通信，是非阻塞

#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <wait.h>

//作业:使用内存映射实现没有关系的进程间的通信
int main(){

    //1. 打开一个文件
    int fd =  open("test.txt",O_RDWR);
    if(fd == -1){
        perror("open");
        return -1;
    }

    int size = lseek(fd,0,SEEK_END); //获取文件的大小

    //2.创建内存映射
    void *ptr = mmap(NULL,size,PROT_READ | PROT_WRITE,MAP_SHARED,fd,0);
    if(ptr == MAP_FAILED){
        perror("mmap");
        exit(0);
    }

    //3.创建子进程
    pid_t pid = fork();
    if(pid > 0){
        wait(NULL);
        //父进程
        strcpy((char*)ptr , "hello!Mike!!");
    }else if(pid == 0){
        //子进程
        char buf[256];
        strcpy(buf,(char *)ptr);
        printf("read data:%s\n",buf);
    }

    //关闭内存映射区
    munmap(ptr,size);

    close(fd);

    return 0;
}

思考问题

如果对mmap的返回值(ptr)做++操作(ptr++),munmap是否能够成功?

void * ptr = mmap(…);
ptr++;//可以对其进行++操作
munmap(ptr,len); //错误，不能正确释放,要保存一下地址，传入保存的地址是可行的

如果open时O_RDONLY，mmap时prot参数指定PROT_READ | PROT_WRITE会怎样？

错误，返回MAP_FAILED
open()函数中的权限建议和prot参数的权限保持一致

如果文件偏移量为1000会怎样？

偏移量必须是4k的整数倍，错误的话会返回MAP_FAILED

mmap什么情况下会调用失败？

第二个参数:length = 0
第三个参数:prot 只指定了写权限
prot PROT_READ | PROT_WRITE 第5个参数fd 通过open函数时指定的O_RDONLY | O_WRONLY

可以open的时候O_CREAT一个新文件来创建映射区吗？

可以的，但是创建的文件的大小如果为0的话，肯定不行
可以对新的文件进行扩展

lseek()
truncate()

mmap后关闭文件描述符，对mmap映射有没有影响？

int fd = open(“XXX”);
mmap(,fd,0);
close(fd):
映射区还存在啊，创建映射区的fd被关闭，没有任何影响

对ptr越界操作会怎样？

void * ptr = mmap(NULL,100,);
会以内存分页的大小指定内存，4k的倍数
越界操作操作的是非法的内存 --》段错误

案例2

需求：使用内存映射实现文件拷贝的功能

思路:

对原始的文件进行内存映射
创建一个新文件(拓展该文件)
把新文件的数据映射到内存中
通过内存拷贝将第一个文件的内存数据拷贝到新的文件内存中
释放资源

#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

int main(){
    //1. 对原始的文件进行内存映射
    int fd = open("english.txt",O_RDWR);
    if(fd == -1){
        perror("open");
        exit(0);
    }

    //获取原始文件的大小
    int len = lseek(fd,0,SEEK_END);

    //2. 创建一个新文件(拓展该文件)
    int fd1 = open("cpy.txt",O_RDWR|O_CREAT,0664);
    if(fd1 == -1){
        perror("open");
        exit(0);
    }

    //拓展文件
    truncate("cpy.txt",len);
    write(fd1," ",1);

    //3. 把新文件的数据映射到内存中
    void *ptr = mmap(NULL,len,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    void *ptr1 = mmap(NULL,len,PROT_READ|PROT_WRITE,MAP_SHARED,fd1,0);

    if(ptr == MAP_FAILED){
        perror("mmap");
        exit(0);
    }
    if(ptr1 == MAP_FAILED){
        perror("mmap");
        exit(0);
    }

    //内存拷贝
    memcpy(ptr1,ptr,len);

    //释放资源
    munmap(ptr1,len);
    munmap(ptr,len);
    //后打开先释放，先打开后释放

    close(fd);
    close(fd1);

    return 0;
}

案例3

匿名映射：不需要文件实体进行内存映射

#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>

int main(){

    //1. 创建匿名内存映射区
    int len = 4096;
    void * ptr = mmap (NULL,len,PROT_READ | PROT_WRITE,MAP_SHARED|MAP_ANONYMOUS,-1,0);
    if(ptr == MAP_FAILED){
        perror("mmap");
        exit(0);
    }

    //父子进程间通信
    pid_t pid = fork();

    if(pid > 0){
        //父进程
        strcpy((char *) ptr,"hello,world");
        wait(NULL);
    }else if(pid == 0){
        //子进程
        sleep(1);
        printf("%s\n",(char*)ptr);
    }

    //释放内存映射区 
    int ret = munmap(ptr,len);
    if(ret == -1){
        perror("munmap");
        exit(0);
    }

    return 0;
}

信号

信号是Linux进程间通信的最古老的方式之一，是时间发生时对进程的通知机制，有时也称之为软件中断，它是在软件层次上对中断机制的一种模拟，是一种异步通信的方式。信号可以导致一个正在运行的进程被另一个正在运行的异步进程中断，转而处理某一个突发事件。

发往进程的诸多信号，通常都是源自于内核。引发内核为进程产生信号的各类事件如下：

对于前台进程，用户可以通过输入特殊的终端字符来给它发送信号。比如输入ctrl+c通常会给进程发送一个中断信号
硬件发生异常，即硬件检测到一个错误条件并通知内核，随即再由内核发送相应信号给相关进程。比如执行一条异常的机器语言指令，诸如被0除，或者引用了无法访问的内存区域
系统状态变化，比如alarm定时器到期将引起SIGALRM信号，进程执行的CPU时间超限，或者该进程的某个子进程退出
运行kill命令或调用kill函数

使用信号的两个主要目的是：

让进程知道已经发生了一个特定事件
强迫进程执行他自己代码中的信号处理程序

信号的特点:

简单
不能携带大量信息
满足某个特定条件才发送
优先级比较高

查看系统定义的信号列表： kill -l
前31个信号为常规信号，其余为实时信号

在这里插入图片描述

信号的5中默认处理动作

查看信号的详细信息:man 7 signal
信号的5种默认处理动作:
- Term 终止进程
- Ign 当前进程忽略掉这个信号
- Core 终止进程，并生成一个Core文件
- Stop 暂停当前进程
- Cont 继续执行当前被暂停的进程
信号的几种状态：产生、未决、递达
SIGKILL和SIGSTOP信号不能被捕捉、阻塞或者忽略，只能执行默认动作

#include <stdio.h>
#include <string.h>

int main(){

    char * buf;

    strcpy(buf,"hello");

    return 0;
}

这样的一段代码在执行时，会报段错误（核心已转储），因为这里指针是野指针，指向野内存
通过ulimit -a来查看系统信息，可以看到core那行的默认值为0
当我们将其修改为1024，再次执行，虽然还是报段错误，但是会生成一个core文件其中保存了产生错误的信息
通过GDB调试，core-file core语句可以查看core中的内容

正常来说修改完，应该会出现一个core文件，但本人在测试的时候并没有出现，这里注意两个点：

gcc编译出来的文件不能命名为core，重名会无法出现想要的效果
我的系统是ubuntu，cat /proc/sys/kernel/core_pattern之后输出|/usr/share/apport/apport %p %s %c %d %P %E，查了之后发现ubuntu预装了apport错误收集系统，sudo service apport stop之后就可以了。
也可以在GDB中查看，直接使用GDB a.out可以看见

(gdb) run
Starting program: /home/fengshou/Linux_server_sufficially/LINUX/day16/a.out

Program received signal SIGSEGV, Segmentation fault.
0x0000555555555135 in main () at core.c:8
8 strcpy(buf, “hello”);
(gdb) Quit

信号相关函数

int kill(pid_t pid,int sig):
int raise(int sig);
void abort(void);
unsigned int alarm(unsigned int seconds);
int setitimer(int which,const struct itimerval *new_val,struct itimerval * old_value);

kill、raise和abort函数

#include <sys/types.h>
#include <signal.h>

int kill(pid_t pid,int sig);

功能:给某个进程或进程组pid ，发送任何的信号 sig
参数:
- pid:需要发送给的进程的id
  pid > 0 :发送给指定的进程
  pid = 0 :发送给进程组内所有进程
  pid = -1 :发送给每个有权限接收这个信号的进程
  pid < -1 :发送给每个在进程组中ID是-pid的进程
- sig:需要发送的信号的编号或者是宏值(推荐使用宏值)
  sig = 0:没有信号发送

eg. kill(getppid(),9);
kill(getpid(),9);

int raise(int sig);

功能:给当前进程发送信号
参数:sig:要发送的信号
返回值:成功返回0，失败返回非0

void abort(void);

功能:发送sIGABRT信号给当前的进程，杀死当前进程

    #include <sys/types.h>
    #include <signal.h>
    #include <stdio.h>
    #include <unistd.h>

    int main(){
        pid_t pid = fork();
        
        if(pid == 0){
            //子进程
            for(int i = 0 ;i < 5;i++){
                printf("child process\n");
                sleep(1);
            }
        }else if(pid > 0){
            //父进程
            printf("parent process\n");
            sleep(2);
            printf("kill child process now\n");
            kill(pid,SIGINT);
        }


        return 0;
    }

在运行的时候，child process会打印2~3次，因为内存中进程是抢时间片运行的，所以在休眠2秒后，肯定会打印2次，概率打印第3次

alarm函数

#include <unistd.h>
unsigned int alarm(unsigned int seconds);

功能:设置定时器(闹钟).函数调用，开始倒计时，当倒计时为0的时候
函数会给当前的进程发送一个信号:SIGALARM
参数:
seconds:倒计时的时长，单位:秒。如果参数为0，定时器无效(不进行倒计时，不发信号)
取消定时器，通过alarm(0).
返回值:
- 之前没有定时器，返回0
- 之前有定时器，返回倒计时剩余的时间
SIGALARM:默认终止当前的进程,每一个进程都有且只有唯一的一个定时器
alarm(10); -->返回0
过了1秒
alarm(5); --> 返回9 //覆盖了之前的倒计时

alarm(100) -> 该函数是不阻塞的

    #include <unistd.h>
    #include <stdio.h>

int main(){

    int seconds = alarm(5);
    printf("seconds = %d\n",seconds); //0
    
    sleep(2);

    seconds = alarm(2); //不阻塞
    printf("seconds = %d\n",seconds); // 3

    while(1){

    }

    return 0;
}

案例

1秒钟电脑能数几个数

#include <unistd.h>
#include <stdio.h>

int main(){
    alarm(1);
    
    int i = 0;
    while(1){
        printf("%d\n",i++);
    }


    return 0;
}

虽然我们这里设置的是1秒，但是实际运行起来不止1秒才会终止，这是因为程序虽然设置了1秒结束，但是输出的数据会存储在缓冲区，在缓冲区中会稍慢的输出，所以在我们看来程序运行了不止1秒
因为I/O函数效率较低，我们可以尝试将输出到一个文件里，会发现输出的数远超在进程中的

./alarm1 >> a.txt

程序实际运行时间 = 内核时间 + 用户程序 + 消耗的时间
进行文件IO操作的时候比较浪费时间

定时器与进程的状态无关（自然定时法）。无论进程处于什么状态，alarm都会计时

setitimer函数

#include <sys/time.h>
int getitimer(int which, struct itimerval *curr_value);
int setitimer(int which, const struct itimerval *new_value,struct itimerval *old_value);

功能:设置定时器(闹钟)。可以替代alarm函数。进度：微妙us,可以实现周期性定时
参数:
- which:定时器以什么时间计时
  ITIMER_REAL: 真实时间，时间到达，发送SIGALARM，常用
  ITIMER_VIRTUAL:用户时间,时间到达，发送SIGVTALRM
  ITIMER_PROT:以该进程在用户态和内核态下所消耗的时间来计算，时间到达，发送SIGPROF
- new_value:设置定时器的属性
  struct itimerval { //定时器的结构体
  struct timeval it_interval; //每个阶段的时间，间隔时间
  struct timeval it_value; //延迟多长时间执行
  };
  
  struct timeval { //时间的结构体
  time_t tv_sec; //秒数
  suseconds_t tv_usec; //微秒
  };
  过10秒后，每隔2秒定时一次
- old_value:记录上一次定时的时间参数，一般不使用，指定NULL
返回值:成功返回0，失败返回-1

#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
 
 //过3秒以后，每隔2秒定时一次
int main(){

    struct itimerval new_value;

    //设置new_value间隔的值
    new_value.it_interval.tv_sec = 2;
    new_value.it_interval.tv_usec = 0;

    //设置延迟的时间
    new_value.it_value.tv_sec = 3;
    new_value.it_value.tv_usec = 0;

    int ret = setitimer(ITIMER_REAL,&new_value,NULL);//非阻塞的
    printf("定时器开始了。。。");
    if(ret == -1){
        perror("setitimer");
        exit(0);
    }

    getchar();

    return 0;
}

因为这个函数是非阻塞的，所以会输出下面的那句话，然后因为getchar()函数要键盘输入才会继续，所以程序会卡在那边，直到定时结束，从而程序终止

signal信号捕捉函数

sighandler_t signal(int signum,sighandler_t handler);
int sigaction(int signum,const struct sigaction *act,struct sigaction *oldact);

#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum,sighandler_t handler);

功能:设置某个信号的捕捉行为
参数:
- signum:要捕捉的信号
- handler:捕捉到信号要如何处理
  - SIG_IGN:忽略信号
  - SIG_DFL:使用信号默认的行为
  - 回调函数:这个函数是内核调用,程序员只负责写,捕捉到信号后如何去处理信号。
    回调函数:
    - 需要程序员实现，提前准备好的，函数的类型根据实际需求，看函数指针的定义
    - 不是程序员调用，而是当信号产生，由内核调用
    - 函数指针是实现回调的手段，函数实现之后，将函数名放到函数指针的位置就可以了
返回值:
成功，返回上一次注册的信号处理函数的地址。第一次调用返回NULL
失败,返回SIG_ERR,设置错误号

SIGKILL SIGSTOP不能被捕捉，不能被忽略.

#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

void myalarm(int num){
    printf("捕捉到了信号的编号是:%d\n",num);
    printf("XXXXXXXXXX\n");
}

//过3秒以后，每隔2秒定时一次
int main(){
    //注册信号捕捉
    //signal(SIGALRM,SIG_IGN);
    //signal(SIGALRM,SIG_DFL);
    //void (*sighandler_t)(int);函数指针,int类型的参数表示捕捉到的信号的值
    signal(SIGALRM,myalarm);

    struct itimerval new_value;

    //设置间隔的时间
    new_value.it_interval.tv_sec = 2;
    new_value.it_interval.tv_usec = 0;

    //设置延迟的时间，3秒之后开始第一次定时
    new_value.it_value.tv_sec = 3;
    new_value.it_value.tv_usec = 0;

    int retur = setitimer(ITIMER_REAL ,&new_value,NULL);//非阻塞
    printf("定时器开始了...\n");

    if(retur == -1){
        perror ("setitimer");
        exit(0);
    }

    getchar();

    return 0;
}