第二章 Linux多进程开发

2.1 进程概述

 

 

 2.2 进程状态转换

 

 

 

 

 kill 9 12151

 2.3 进程创建

/*
    man 2 fork
    #include <sys/types.h>
    #include <unistd.h>
    pid_t fork(void);
        作用:用于创建子进程
        返回值:
            fork()的返回值会返回两次。一次是在父进程中,一次是在子进程中。
            在父进程中返回子进程的PID,在子进程中返回0.
            如何区分父进程和子进程:通过fork的值。
            在父进程中返回-1,表示创建子进程失败,并设置erron
*/
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>


int main(){

    // 创建子进程
    pid_t pid = fork();

    // 判断是父进程还是子进程
    if(pid > 0){
        printf("pid = %d\n", pid);
        // 父进程,如果大于0,返回的是创建的子进程的进程号
        printf("Parent process, pid = %d, ppid = %d\n", getpid(), getppid());

    }
    else if(pid == 0){
        // 子进程
        printf("Child process, pid = %d, ppid = %d\n", getpid(), getppid());
    }

    for(int i = 0; i < 3; ++i){
        printf("i = %d, pid = %d \n", i, getpid());
        sleep(1);
    }

    return 0;
}

 

 2.4 父子进程虚拟地址空间情况

 

写时拷贝, 


实际上,更准确来说,Linux 的 fork() 使用是通过写时拷贝 (copy- on-write) 实现。
写时拷贝是一种可以推迟甚至避免拷贝数据的技术。
内核此时并不复制整个进程的地址空间,而是让父子进程共享同一个地址空间。
只用在需要写入的时候才会复制地址空间,从而使各个进行拥有各自的地址空间。
也就是说,资源的复制是在需要写入的时候才会进行,在此之前,只有以只读方式共享。
注意:fork之后父子进程共享文件,
fork产生的子进程与父进程相同的文件文件描述符指向相同的文件表,引用计数增加,共享文件偏移指针。

 

 

 2.5 父子进程关系及GDB多进程调试

        父子进程之间的关系:
        区别:
            1.fork()函数的返回值不同
                父进程中:>0 返回子进程的PID
                子进程:=0
            2.pcb中的一些数据
                当前的进程的Pid
                当前进程父进程的Pid
                信号集
        共同点:
            某些状态下:子进程刚被创建出来,还没有执行任何的写数据的操作
                - 用户区的数据
                - 文件描述符表(在内核区)

        父子进程对变量是不是共享的?
            - 刚开始的时候,是一样的,共享的。如果修改了数据,就不共享了。
            - 读时共享(子进程被创建,两个进程没有进行写操作),写时拷贝。

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

int main() {

    printf("begin\n");

    if(fork() > 0) {

        printf("我是父进程:pid = %d, ppid = %d\n", getpid(), getppid());

        int i;
        for(i = 0; i < 10; i++) {
            printf("i = %d\n", i);
            sleep(1);
        }

    } else {

        printf("我是子进程:pid = %d, ppid = %d\n", getpid(), getppid());
        
        int j;
        for(j = 0; j < 10; j++) {
            printf("j = %d\n", j);
            sleep(1);
        }

    }

    return 0;
}

 gdb 默认调试的是父进程

 设置跟踪子进程

 设置调试模式

 

2.6 exec函数族

 

/*
    man 3 execl
    #include <unistd.h>
    int execl(const char *path, const char *arg, ...);
        参数:
            - path:需要指定的执行文件的路径或名称
            - arg:是执行可执行文件所需要的参数列表
                第一个参数一般没有什么作用,为了方便,一般写的是执行程序的名称
                从第二个参数开始往后,就是执行程序所需要的参数列表。
                参数需要最后以NULL结束。
        返回值:只有当调用失败是才返回-1,并设置errno

*/

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

int main(){

    // 创建一个子进程,在子进程中执行exec函数族的函数
    pid_t pid = fork();

    if(pid > 0){
        //父进程
        printf("I am parent process, pid = %d\n", getpid());
    }
    else{
        //子进程
        printf("I am child process, pid = %d\n", getpid());
        execl("hello","hello",NULL);
        printf(" I am child process\n");
    }
    for(int i = 0; i < 3; ++i){
        printf("i = %d, pid = %d \n", i, getpid());
    }


    
    return 0;
}

/*
    man 3 execlp
    #include <unistd.h>
    int execlp(const char *file, const char *arg, ...);
        会到环境变量中查找指定的可执行文件,如果找到了就执行,找不到就执行不成功。
        参数:
            - file:需要执行的可执行文件的文件名
            - arg:是执行可执行文件所需要的参数列表
                第一个参数一般没有什么作用,为了方便,一般写的是执行程序的名称
                从第二个参数开始往后,就是执行程序所需要的参数列表。
                参数需要最后以NULL结束。
        返回值:只有当调用失败是才返回-1,并设置errno

*/

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

int main(){

    // 创建一个子进程,在子进程中执行exec函数族的函数
    pid_t pid = fork();

    if(pid > 0){
        //父进程
        printf("I am parent process, pid = %d\n", getpid());
    }
    else{
        //子进程
        printf("I am child process, pid = %d\n", getpid());
        execlp("ps", "ps", "aux", NULL);
        printf(" I am child process\n");
    }
    for(int i = 0; i < 3; ++i){
        printf("i = %d, pid = %d \n", i, getpid());
    }


    
    return 0;
}

2.8进程退出、孤儿进程、僵尸进程

/*
    标准c库中
    #include <stdlib.h>
    void exit(int status);

    linux库中
    #include <unistd.h>
    void _exit(int status);

    status参数:是进程退出时的一个状态信息。父进程回收子进程资源时可以获取到。

    一般使用标准c库中的
*/

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

int main(){

    printf("hello\n");
    printf("world");

    //exit(0);
    _exit(0);

    return 0;
}


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


int main(){

    // 创建子进程
    pid_t pid = fork();

    // 判断是父进程还是子进程
    if(pid > 0){
        // printf("pid = %d\n", pid);
        // // 父进程,如果大于0,返回的是创建的子进程的进程号
        printf("Parent process, pid = %d, ppid = %d\n", getpid(), getppid());

    }
    else if(pid == 0){
        // 子进程
        sleep(1);
        printf("\nChild process, pid = %d, ppid = %d\n", getpid(), getppid());
        
    }

    for(int i = 0; i < 3; ++i){
        printf("i = %d, pid = %d \n", i, getpid());
        //sleep(1);
    }

    return 0;
}

 我们可以看到子进程的父进程变成ppid,孤儿进程。


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


int main(){

    // 创建子进程
    pid_t pid = fork();

    // 判断是父进程还是子进程
    if(pid > 0){
        while(1){
            printf("Parent process, pid = %d, ppid = %d\n", getpid(), getppid());
            sleep(1);
        }

    }
    else if(pid == 0){
        // 子进程
        printf("\nChild process, pid = %d, ppid = %d\n", getpid(), getppid());
        
    }

    for(int i = 0; i < 3; ++i){
        printf("i = %d, pid = %d \n", i, getpid());
        //sleep(1);
    }

    return 0;
}

存在僵尸进程实际上就是父进程创建了子进程,子进程运行结束了内核区的数据回收不了,而父进程一直没有死,回收不了子进程。

 2.8 wait函数

/*
    man 2 wait
    #include <sys/types.h>
    #include <sys/wait.h>
    pid_t wait(int *wstatus);
        作用:等待任意一个子进程结束,如果任意一个子进程结束了,这个函数会回收子进程的资源。阻塞的函数
        参数:int *wstatus
            进程退出时的状态信息,传入的是一个int类型的地址,传出参数。
        返回值:
            成功:返回被回收子进程的id
            失败:-1(所有的子进程都结束或者调用失败)
        
    调用wait函数的进程会被挂起(阻塞),直到他的一个子进程退出或者收到一个不能被忽略的信号,才被唤醒。
    如果没有子进程,函数立刻返回-1。子进程都结束了也会返回-1。

*/
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>


int main() {

    // 有一个父进程,创建5个子进程(兄弟)
    pid_t pid;

    // 创建5个子进程
    for(int i = 0; i < 5; i++) {
        pid = fork();
        if(pid == 0) {
            break;
        }
    }

    if(pid > 0) {
        // 父进程
        while(1) {
            printf("parent, pid = %d\n", getpid());

            // int ret = wait(NULL);
            int st;
            int ret = wait(&st);

            if(ret == -1) {
                break;
            }

            if(WIFEXITED(st)) {
                // 是不是正常退出
                printf("退出的状态码:%d\n", WEXITSTATUS(st));
            }
            if(WIFSIGNALED(st)) {
                // 是不是异常终止
                printf("被哪个信号干掉了:%d\n", WTERMSIG(st));
            }

            printf("child die, pid = %d\n", ret);

            sleep(1);
        }

    } else if (pid == 0){
        // 子进程
         while(1) {
            printf("child, pid = %d\n",getpid());    
            sleep(1);       
         }

        exit(0);
    }

    return 0; // exit(0)
}

  

五个僵尸子进程 

 加入wait函数后

 2.9 waitpid函数

/*
    man 2 waitpid 
    #include <sys/types.h>
    #include <sys/wait.h>
    pid_t waitpid(pid_t pid, int *wstatus, int options);
        作用:回收指定进程号pid的子进程,还可以设置是否阻塞(默认是阻塞的)。
        参数:
            - pid:
                > 0:某个子进程的pid
                = 0:回收当前进程组的所有子进程
                = -1:回收所有的子进程,最常用。相当于wait()
                < -1:某个进程组的组id,回收这id绝对值组中的子进程。
            - wastatus:
                进程退出时的状态信息,传入的是一个int类型的地址,传出参数。
            - options:设置阻塞或者非阻塞
                0阻塞,WNOHANG非阻塞。
        返回值:
            > 0:返回子进程的pid
            = 0:options=WNOHANG,表示还有子进程活着。
            = -1:表示错误或者没有子进程了。
*/

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


int main() {

    // 有一个父进程,创建5个子进程(兄弟)
    pid_t pid;

    // 创建5个子进程
    for(int i = 0; i < 5; i++) {
        pid = fork();
        if(pid == 0) {
            break;
        }
    }

    if(pid > 0) {
        // 父进程
        while(1) {
            printf("parent, pid = %d\n", getpid());
            sleep(1);

            // int ret = wait(NULL);
            int st;
            //int ret = waitpid(-1, &st, 0);
            int ret = waitpid(-1, &st, WNOHANG);

            if(ret == -1) {
                break;
            }
            else if(ret == 0){
                //说明还有子进程存在
                continue;
            }
            else if(ret > 0){
                if(WIFEXITED(st)) {
                    // 是不是正常退出
                    printf("退出的状态码:%d\n", WEXITSTATUS(st));
                }
                if(WIFSIGNALED(st)) {
                    // 是不是异常终止
                    printf("被哪个信号干掉了:%d\n", WTERMSIG(st));
                }

                printf("child die, pid = %d\n", ret);
            }
        }

    } else if (pid == 0){
        // 子进程
         while(1) {
            printf("child, pid = %d\n",getpid());    
            sleep(1);       
         }

        exit(0);
    }

    return 0; // exit(0)
}

2.10 进程间通信间接

 2.11 匿名管道概述

 

2.12 父子进程通过匿名管道通信

 

/*
    man 2 pipe
    #include <unistd.h>
    int pipe(int pipefd[2]);
        作用:创建一个匿名管道用于进程通信
        参数:int pipefd[2] 这个数组是一个传出参数。
            pipefd[0]对应的是管道的读段
            pipedf[1]对应的是管道的写段
        返回值:
            成功返回0,失败返回-1。

    管道默认是阻塞的:如果管道空,read阻塞,如果管道慢write阻塞。
    
    注意:匿名管道只能用于具有关系的进程之间的通信。

*/

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

//子进程发送数据给父进程,父进程读取数据输出
int main(){

    //在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);
    if(ret == -1){
        perror("pipe");
        exit(0);
    }

    pid_t pid = fork();
    if(pid > 0){
        //父进程从管道读段读取数据
        char buf[1024]={0};
        int len = read(pipefd[0], buf, sizeof(buf));
        printf("Parent read : %s, pid = %d\n", buf, getpid());

    }
    else if(pid == 0){
        //子进程向管道中写数据
        sleep(10);
        char *str = "Hello,i am child";
        write(pipefd[1], str, strlen(str));
    }
    return 0;
}

 父子进程相互读写数据

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

//子进程发送数据给父进程,父进程读取数据输出
int main(){

    //在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);
    if(ret == -1){
        perror("pipe");
        exit(0);
    }

    pid_t pid = fork();
    if(pid > 0){
        //父进程从管道读段读取数据
        printf("Parent process, pid = %d\n", getpid());
        char buf[1024]={0};
        while(1){
            int len = read(pipefd[0], buf, sizeof(buf));
            printf("Parent read : %s, pid = %d\n", buf, getpid());

            //向管道中写数据
            char *str = "Hello,i am Parent";
            write(pipefd[1], str, strlen(str));
            sleep(1);
        }
        

    }
    else if(pid == 0){
        //子进程向管道中写数据
        printf("Child process, pid = %d\n", getpid());
        char buf[1024]={0};
        while(1){

            //向管道中写数据
            char *str = "Hello,i am child";
            write(pipefd[1], str, strlen(str));
            sleep(1);

            int len = read(pipefd[0], buf, sizeof(buf));
            printf("Child read : %s, pid = %d\n", buf, getpid());

        }
        
    }
    return 0;
}

 

获取管道的大小

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

int main(){

    int pipefd[2];

    int ret = pipe(pipefd);

    //获取管道的大小
    long size = fpathconf(pipefd[0], _PC_PIPE_BUF); 
    printf("pipe size : %ld\n", size);
}

 2.13 匿名管道通信案例

有问题,把sleep删除后读到的都是自己写入的内容。

一般我们不会让两个相互读取数据。

/*
    实现 ps aux | grep xxx 的功能 父子进程间通信

    子进程:ps aux,子进程结束后将数据发送给父进程
    父进程:获取到数据,过滤。

    pipe();
    execlp();
    子进程将标准输出 stdout_fileno 重定向到管道的写端。  dup2();
*/


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

int main(){

    //创建一个管道
    int fd[2];
    int ret = pipe(fd);
    if(ret == -1){
        perror("pipe");
        exit(0);
    }

    //创建子进程
    pid_t pid = fork();

    if(pid > 0){
        //父进程
        //关闭写端
        close(fd[1]);
        //从管道中读取数据
        char buf[1024] = {0};
        int len ;
        while( len = read(fd[0], buf, strlen(buf)) > 0){
            //过滤数据输出
            printf("%s", buf);
            memset(buf, 0, 1024);
        }
        wait(NULL);
        
    }
    else if(pid == 0){
        //子进程
        //关闭读段
        close(fd[0]);
        //文件描述符的重定向 stdout_fileno 重定向到 fd[1];
        dup2(fd[1], STDERR_FILENO);
        //执行 ps aux
        execlp("ps", "ps", "aux", NULL);
        perror("execlp");
        exit(0);
    }
    else{
        perror("fork");
        exit(0);
    }




    return 0;;
}

 2.14 管道的读写特点和管道设置为非阻塞

管道的读写特点
使用管道时,需要注意以下几种特殊的情况(默认是阻塞I/O操作)

1.所有的指向管道写端的文件描述符都关闭了(管道写端引用计数为0),有进程从管道的读端
读数据,那么管道中剩余的数据被读取以后,再次read会返回0,就像读到文件末尾一样。

2.如果有指向管道写端的文件描述符没有关闭(管道的写端引用计数大于0),而持有管道写端的进程
也没有往管道中写数据,这个时候有进程从管道中读取数据,那么管道中剩余的数据被读取后,
再次read会阻塞,直到管道中有数据可以读了才读取数据并返回。

3.如果所有指向管道读端的文件描述符都关闭了(管道的读端引用计数为0),这个时候有进程
向管道中写数据,那么该进程会收到一个信号SIGPIPE, 通常会导致进程异常终止。

4.如果有指向管道读端的文件描述符没有关闭(管道的读端引用计数大于0),而持有管道读端的进程
也没有从管道中读数据,这时有进程向管道中写数据,那么在管道被写满的时候再次write会阻塞,
直到管道中有空位置才能再次写入数据并返回。

总结:
    读管道:
        管道中有数据,read返回实际读到的字节数。
        管道中无数据:
            写端被全部关闭,read返回0(相当于读到文件的末尾)
            写端没有完全关闭,read阻塞等待

    写管道:
        管道读端全部被关闭,进程异常终止(进程收到SIGPIPE信号)
        管道读端没有全部关闭:
            管道已满,write阻塞
            管道没有满,write将数据写入,并返回实际写入的字节数

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


/*
    设置管道非阻塞
    int flags = fcntl(fd[0], F_GETFL); //获取原来的flags
    flags |= O_NONBLOCK; //修改flags
    fcntl(fd[0], F_SETFL, flags); //设置新的flags

*/

int main(){

    //在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);
    if(ret == -1){
        perror("pipe");
        exit(0);
    }

    pid_t pid = fork();
    if(pid > 0){
        //父进程从管道读段读取数据
        printf("Parent process, pid = %d\n", getpid());
        //关闭写段
        close(pipefd[1]);
        char buf[1024]={0};

        //设置读管道非阻塞
        int flags = fcntl(pipefd[0], F_GETFL); //获取原来的flags
        flags |= O_NONBLOCK; //修改flags
        fcntl(pipefd[0], F_SETFL, flags); //设置新的flags

        while(1){
            int len = read(pipefd[0], buf, sizeof(buf));
            printf("len = %d\n", len);
            printf("Parent read : %s, pid = %d\n", buf, getpid());
            memset(buf, 0, 1024);
            sleep(1);
        }
    }
    else if(pid == 0){
        //子进程向管道中写数据
        printf("Child process, pid = %d\n", getpid());
        //关闭读段
        close(pipefd[0]);
        char buf[1024]={0};
        while(1){
            //向管道中写数据
            char *str = "Hello,i am child";
            write(pipefd[1], str, strlen(str));
            sleep(5);
        }
        
    }
    return 0;
}

2.15 有名管道介绍及使用

//向有名管道中写入数据

/*
    有名管道的注意事项
        1.一个是只读打开一个管道的进程会阻塞,直到有一个可以写的管道的进程
        2.一个是只写打开一个管道的进程会阻塞,直到有一个可以读的管道的进程

    读管道:
        管道中有数据,read返回实际读到的字节数。
        管道中无数据:
            写端被全部关闭,read返回0(相当于读到文件的末尾)
            写端没有完全关闭,read阻塞等待

    写管道:
        管道读端全部被关闭,进程异常终止(进程收到SIGPIPE信号)
        管道读端没有全部关闭:
            管道已满,write阻塞
            管道没有满,write将数据写入,并返回实际写入的字节数
*/

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


int main(){

    //1.判断管道是否存在
    int ret = access("test", F_OK);
    if(ret == -1){
        //2.创建管道
        printf("创建管道\n");
        ret = mkfifo("test", 0664);
        if(ret == -1){
            perror("mkfifo");
            exit(0);
        }
    }

    //3.以只写的方式打开管道
    int fd = open("test", O_WRONLY);
    if(fd == -1){
        perror("open");
        exit(0);
    }

    //写数据
    for(int i = 0; i < 100; ++i){
        char buf[1024];
        sprintf(buf, "hello, %d\n", i);
        printf("write date : %s\n", buf);
        write(fd, buf, strlen(buf));
        sleep(1);
    }
    close(fd);
    return 0;
}
//从有名管道中读取数据

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

int main(){
    
    //1.以只读的方式打开管道文件
    int fd = open("test", O_RDONLY);
    if(fd == -1){
        perror("open");
        exit(0);
    }

    //读数据
    while(1){
        char buf[1024] = {0};
        int len = read(fd, buf, sizeof(buf));
        if(len == 0){
            printf("写端断开连接了...\n");
            break;;
        }
        printf("reveive buf : %s\n", buf);
    }
    close(fd);
    return 0;
}

2.16 有名管道实现简单版聊天功能

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

int main(){

    //1.判断有名管道是否存在
    int ret = access("fifo1", F_OK);
    if(ret == -1){
        //创建管道
        printf("管道不存在,创建对应的有名管道\n");
        ret = mkfifo("fifo1", 0664);
        if(ret == -1){
            perror("mkfifo");
            exit(0);
        }
    }

    ret = access("fifo2", F_OK);
    if(ret == -1){
        //创建管道
        printf("管道不存在,创建对应的有名管道\n");
        ret = mkfifo("fifo2", 0664);
        if(ret == -1){
            perror("mkfifo");
            exit(0);
        }
    }

    //2.以只写的方式打开fifo1
    int fdw = open("fifo1", O_WRONLY);
    if(fdw == -1){
        perror("open");
        exit(0);
    }
    printf("打开管道fifo1成功,等待写入数据...\n");

    //3.以只读的方式打开fifo2
    int fdr = open("fifo2", O_RDONLY);
    if(fdr == -1){
        perror("open");
        exit(0);
    }
    printf("打开管道fifo2成功,等待读取...\n");

    //4.循环的写读数据
    char buf[128];
    while(1){
        memset(buf, 0, 128);
        //获取标准输入的数据
        fgets(buf, 128, stdin);
        //写数据
        int ret = write(fdw, buf, strlen(buf));
        if(ret == -1){
            perror("write");
            exit(0);
        }
        //读数据
        memset(buf, 0, 128);
        ret = read(fdr, buf, 128);
        if(ret <= 0){
            perror("read");
            break;
        }
        printf("buf : %s\n", buf);
    }
    close(fdr);
    close(fdw);
    return 0;
}
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>

int main(){

    //1.判断有名管道是否存在
    int ret = access("fifo1", F_OK);
    if(ret == -1){
        //创建管道
        printf("管道不存在,创建对应的有名管道\n");
        ret = mkfifo("fifo1", 0664);
        if(ret == -1){
            perror("mkfifo");
            exit(0);
        }
    }

    ret = access("fifo2", F_OK);
    if(ret == -1){
        //创建管道
        printf("管道不存在,创建对应的有名管道\n");
        ret = mkfifo("fifo2", 0664);
        if(ret == -1){
            perror("mkfifo");
            exit(0);
        }
    }

    //2.以只读的方式打开fifo1
    int fdr = open("fifo1", O_RDONLY);
    if(fdr == -1){
        perror("open");
        exit(0);
    }
    printf("打开管道fifo1成功,等待读取...\n");

    //3.以只写的方式打开fifo2
    int fdw = open("fifo2", O_WRONLY);
    if(fdw == -1){
        perror("open");
        exit(0);
    }
    printf("打开管道fifo2成功,等待写入数据...\n");

    //4.循环的读写数据
    char buf[128];
    while(1){
        //读数据
        memset(buf, 0, 128);
        ret = read(fdr, buf, 128);
        if(ret <= 0){
            perror("read");
            break;
        }
        printf("buf : %s\n", buf);

        memset(buf, 0, 128);
        //获取标准输入的数据
        fgets(buf, 128, stdin);
        //写数据
        int ret = write(fdw, buf, strlen(buf));
        if(ret == -1){
            perror("write");
            exit(0);
        }
    }
    close(fdr);
    close(fdw);
    return 0;
}

2.17(1) 内存映射

/*
    man 2 mmap
    #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,建议使用文件的长度。
                    获取文件的长度:stat 或 lseek
            - prot:对申请内存映射区的操作权限
                PROT_EXEC:可执行的权限。Pages may be executed.
                PROT_READ:读的权限。  Pages may be read.
                PROT_WRITE:写权限。 Pages may be written.
                PROT_NONE:没有权限。 Pages may not be accessed.
                要操作映射内存,必须有读的权限。
                PROT_READ、PROT_READ | PROT_WRITE
            - flags:
                MAP_SHARED:映射区的数据会自动和磁盘文件进行同步,进程间通信,必须要设置这个选项。
                MAP_PRIVATE:不同步,内存映射区的数据改变了,对原来的文件不会修改,会重新创建一个新的文件(copy on write)
            - fd:需要映射的那个文件的文件描述符,
                - 通过open得到的,open的是一个磁盘文件
                - 注意:文件的大小大于0,不能为0。open指定的权限不能和prot参数有冲突。
            - offset:偏移量,一般不用,必须指定的是4K的整数倍,0表示不偏移。
        返回值:返回创建的内存的首地址。失败返回MAP_FAILED(that is, (void *) -1)

    int munmap(void *addr, size_t length);
        作用:释放内存映射
        参数:
            - addr:要释放内存的首地址
            - length:要释放内存的大小,和mmap中length参数值一样
*/

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

    注意:内存映射区通信,是非阻塞。
*/
#include <stdio.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <wait.h>

int main(){

    //1.打开一个文件
    int fd = open("test.txt", O_RDWR);
    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);
        char buf[64];
        strcpy(buf, (char *)ptr);
        printf("read date : %s\n", buf);
    } 
    else if(pid == 0){
        strcpy((char *)ptr, "nihao a, son!!!");
    }

    munmap(ptr, size);
    close(fd);

    return 0;
}

2.18 内存映射(2)

1.如果对mmap的返回值(ptr)做++操作(ptr++), munmap是否能够成功?
void * ptr = mmap(...);
ptr++;  可以对其进行++操作
munmap(ptr, len);   // 错误,要保存地址

2.如果open时O_RDONLY, mmap时prot参数指定PROT_READ | PROT_WRITE会怎样?
错误,返回MAP_FAILED
open()函数中的权限建议和prot参数的权限保持一致。

3.如果文件偏移量为1000会怎样?
偏移量必须是4K的整数倍,返回MAP_FAILED

4.mmap什么情况下会调用失败?
    - 第二个参数:length = 0
    - 第三个参数:prot
        - 只指定了写权限
        - prot PROT_READ | PROT_WRITE
          第5个参数fd 通过open函数时指定的 O_RDONLY / O_WRONLY

5.可以open的时候O_CREAT一个新文件来创建映射区吗?
    - 可以的,但是创建的文件的大小如果为0的话,肯定不行
    - 可以对新的文件进行扩展
        - lseek()
        - truncate()

6.mmap后关闭文件描述符,对mmap映射有没有影响?
    int fd = open("XXX");
    mmap(,,,,fd,0);
    close(fd); 
    映射区还存在,创建映射区的fd被关闭,没有任何影响。

7.对ptr越界操作会怎样?
void * ptr = mmap(NULL, 100,,,,,);
4K
越界操作操作的是非法的内存 -> 段错误

// 使用内存映射实现文件拷贝的功能
/*
    思路:
        1.对原始的文件进行内存映射
        2.创建一个新文件(拓展该文件)
        3.把新文件的数据映射到内存中
        4.通过内存拷贝将第一个文件的内存数据拷贝到新的文件内存中
        5.释放资源
*/
#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.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(fd1);
    close(fd);

    return 0;
}

2.19 信号概述

 

 

 

 2.20 kill、raise、abort函数

修改生成core文件

 

/*
    man 2 kill
    #include <sys/types.h>
    #include <signal.h>
    int kill(pid_t pid, int sig);
        作用:给某个进程pid或者进程组,发送某个信号sig
        参数:
            - pid:需要发送给的进程id
                > 0:将信号发送给指定的进程
                = 0:将信号发送给当前的进程组
                = -1:将信号发送给每一个有权限接受这个信号的进程
                < -1:这个pid=某个进程组的id取反

            - sig:需要发送的信号的编号或者宏值,0表示不发送任何信号
        kill(getppid(), 9);
        kill(getpid(), 9);

    #include <signal.h>
    int raise(int sig);
        作用:给当前进程发送信号
        参数
            - sig:需要发送的信号的编号或者宏值,0表示不发送任何信号
        返回值:成功0,失败非0

    void abort(void);
        作用:发送SIGABRT信号给当前进程,杀死当前进程
*/

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

int main(){

    pid_t pid = fork();

    if(pid > 0){
        printf("parent process\n");
        sleep(2);
        printf("kill child process\n");
        kill(pid, 9);
    }
    else if(pid == 0){
        int i = 0;
        for(int i = 0; i < 5; ++i){
            printf("child process\n");
            sleep(1);
        }
    }



    return 0;
}

2.21 alarm 函数

/*
    man 2 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 <stdio.h>
#include <unistd.h>

int main(){

    int seconds = alarm(5);
    printf("seconds = %d\n", seconds);

    sleep(2);
    seconds = alarm(2);
    printf("seconds = %d\n", seconds);

    while(1){

    }


    return 0;
}

//1秒钟电脑能数多少个数?

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

/*
    实际的运行时间 = 内核时间 + 用户时间 + 消耗时间
    进行文件I/O操作是十分浪费时间的

    定时器,与进程的状态无关(自然定时发)。无论进程处于什么状态,alarm都会计时。
*/
int main(){

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

    return 0;
}

2.22 setitimer定时器函数

/*
    man 2 setitimer
    #include <sys/time.h>
    int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value);
        作用:设置定时器。可以替代alarm。精度微妙,可以实现周期性的定时。
        参数:
            - which:定时器以什么时间定时
                ITIMER_REAL:真实时间,时间到达,发送SIGALRM  常用
                ITIMER_VIRTUAL:用户时间,时间到达,发送SIGVTALRM
                ITIMER_PROF:以该进程在用户态和内核态下所消耗的时间来计算,时间到达,发送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>

//过3秒以后,每隔2秒钟定时一次
int main(){
    struct itimerval new_value;

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

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

    int ret = setitimer(ITIMER_REAL, &new_value, NULL);
    printf("定时器开始了\n");

    if(ret == -1){
        perror("setitimer");
        return -1;
    }

    getchar();

    return 0;
}

2.23 signal信号捕获函数

/*
    man 2 signal
    #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,设置错误号。
    The signals SIGKILL and SIGSTOP cannot be caught or ignored(捕捉和忽略)
*/

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

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

//过3秒以后,每隔2秒钟定时一次
int main(){

    //注册信号捕捉
    //signal(SIGALRM, SIG_IGN);
    //signal(SIGALRM, SIG_DFL);
    //void (*sighandler_t)(int); 函数指针, int类型的参数表示捕捉到的信号的值
    signal(SIGALRM, myalarm);
    // if(ret1 == SIG_ERR){
    //     perror("signal");
    //     return -1;
    // }


    struct itimerval new_value;

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

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

    int ret = setitimer(ITIMER_REAL, &new_value, NULL);
    printf("定时器开始了\n");

    if(ret == -1){
        perror("setitimer");
        return -1;
    }

    getchar();

    return 0;
}

2.24 信号集及相关函数

 

阻塞信号集和未决信号集
1.用户通过键盘  Ctrl + C, 产生2号信号SIGINT (信号被创建)

2.信号产生但是没有被处理 (未决)
    - 在内核中将所有的没有被处理的信号存储在一个集合中 (未决信号集)
    - SIGINT信号状态被存储在第二个标志位上
        - 这个标志位的值为0, 说明信号不是未决状态
        - 这个标志位的值为1, 说明信号处于未决状态
    
3.这个未决状态的信号,需要被处理,处理之前需要和另一个信号集(阻塞信号集),进行比较
    - 阻塞信号集默认不阻塞任何的信号
    - 如果想要阻塞某些信号需要用户调用系统的API

4.在处理的时候和阻塞信号集中的标志位进行查询,看是不是对该信号设置阻塞了
    - 如果没有阻塞,这个信号就被处理
    - 如果阻塞了,这个信号就继续处于未决状态,直到阻塞解除,这个信号就被处理

 

/*
    以下信号集相关的函数都是对自定义的信号集进行操作。

    int sigemptyset(sigset_t *set);
        - 功能:清空信号集中的数据,将信号集中的所有的标志位置为0
        - 参数:set,传出参数,需要操作的信号集
        - 返回值:成功返回0, 失败返回-1

    int sigfillset(sigset_t *set);
        - 功能:将信号集中的所有的标志位置为1
        - 参数:set,传出参数,需要操作的信号集
        - 返回值:成功返回0, 失败返回-1

    int sigaddset(sigset_t *set, int signum);
        - 功能:设置信号集中的某一个信号对应的标志位为1,表示阻塞这个信号
        - 参数:
            - set:传出参数,需要操作的信号集
            - signum:需要设置阻塞的那个信号
        - 返回值:成功返回0, 失败返回-1

    int sigdelset(sigset_t *set, int signum);
        - 功能:设置信号集中的某一个信号对应的标志位为0,表示不阻塞这个信号
        - 参数:
            - set:传出参数,需要操作的信号集
            - signum:需要设置不阻塞的那个信号
        - 返回值:成功返回0, 失败返回-1

    int sigismember(const sigset_t *set, int signum);
        - 功能:判断某个信号是否阻塞
        - 参数:
            - set:需要操作的信号集
            - signum:需要判断的那个信号
        - 返回值:
            1 : signum被阻塞
            0 : signum不阻塞
            -1 : 失败

*/

#include <signal.h>
#include <stdio.h>

int main() {

    // 创建一个信号集
    sigset_t set;

    // 清空信号集的内容
    sigemptyset(&set);

    // 判断 SIGINT 是否在信号集 set 里
    int ret = sigismember(&set, SIGINT);
    if(ret == 0) {
        printf("SIGINT 不阻塞\n");
    } else if(ret == 1) {
        printf("SIGINT 阻塞\n");
    }

    // 添加几个信号到信号集中
    sigaddset(&set, SIGINT);
    sigaddset(&set, SIGQUIT);

    // 判断SIGINT是否在信号集中
    ret = sigismember(&set, SIGINT);
    if(ret == 0) {
        printf("SIGINT 不阻塞\n");
    } else if(ret == 1) {
        printf("SIGINT 阻塞\n");
    }

    // 判断SIGQUIT是否在信号集中
    ret = sigismember(&set, SIGQUIT);
    if(ret == 0) {
        printf("SIGQUIT 不阻塞\n");
    } else if(ret == 1) {
        printf("SIGQUIT 阻塞\n");
    }

    // 从信号集中删除一个信号
    sigdelset(&set, SIGQUIT);

    // 判断SIGQUIT是否在信号集中
    ret = sigismember(&set, SIGQUIT);
    if(ret == 0) {
        printf("SIGQUIT 不阻塞\n");
    } else if(ret == 1) {
        printf("SIGQUIT 阻塞\n");
    }

    return 0;
}

 2.25 sigprocmaks函数使用

/*
    man 2 sigprocmask
    #include <signal.h>
    int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
        作用:将自定义信号集中的数据设置到内核中(设置阻塞,解除阻塞,替换)
        参数:
            - how:如何对内核阻塞信号集进行处理
                SIG_BLOCK:将用户设置的阻塞信号集添加到内核中,内核中原理的数据不变
                    假设内核中默认的阻塞信号集是mask,mask = mask | set;
                SIG_UNBLOCK:根据用户设置的数据,对内核中的数据进行解除阻塞
                    mask = mask & ~set
                SIG_SETMASK:覆盖内核中原来的值
            - set:已经初始好的用户自定义的信号集
            - oldset:保存设置之前内核中的阻塞信号集的状态,可以NULL
        返回值:
            成功0, 失败-1,设置错误号 EFAULT 、 EINVAL
                
    int sigpending(sigset_t *set);
        作用:获取内核中的未决信号集
        参数:
            - set:传出参数,保存内核中未决信号集的信息
        返回值:
            0成功,-1失败。

*/

//编写一个程序,把所有的常规信号(1-31)的未决状态打印到屏幕
//设置某些状态是阻塞的,通过键盘产生这些信号
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

int main(){

    //设置2和3信号阻塞
    sigset_t set;
    sigemptyset(&set);
    //将二号和三号添加到信号集中
    sigaddset(&set, SIGINT);
    sigaddset(&set, SIGQUIT);

    //修改内核中的阻塞信号集
    sigprocmask(SIG_BLOCK, &set, NULL);

    int num = 0;
    while(1){
        num++;
        //获取当前未决信号集的数据
        sigset_t pendingset;
        sigemptyset(&pendingset);
        sigpending(&pendingset);

        //遍历32位
        for(int i = 1; i <= 32; ++i){
            if(sigismember(&pendingset, i) == 1){
                printf("1");
            }
            else if(sigismember(&pendingset, i) == 0){
                printf("0");
            }
        }
        printf("\n");

        sleep(1);
        if(num == 10){
            //解除阻塞
            sigprocmask(SIG_UNBLOCK, &set, NULL);
        }
    }

    return 0;
}

2.26 sigaction信号捕捉函数

/*
    man 2 sigaction
    #include <signal.h>
    int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
        作用:检查或者改变信号的处理,信号捕捉
        参数:
            - signum:需要捕捉信号的编号或者宏值(信号的名称)
            - act:捕捉到信号之后的处理动作
            - oldact:上一次对信号捕捉的相关设置,一般不适用,设置NULL
        返回值:成功0,失败-1


    struct sigaction {
        //函数指针,指向的函数就是信号捕捉到之后的处理函数
        void     (*sa_handler)(int);
        //不常用
        void     (*sa_sigaction)(int, siginfo_t *, void *);
        //临时阻塞信号集,在信号捕捉函数执行过程中,临时阻塞某些信号
        sigset_t   sa_mask;
        //使用哪一个信号处理对捕捉到的信号进行处理
        //这个值0表示使用sa_handler,也可以是SA_SIGINFO表示使用sa_sigaction
        int        sa_flags;
        //被废弃了
        void     (*sa_restorer)(void);
    };
*/

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

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

//过3秒以后,每隔2秒钟定时一次
int main(){

    struct sigaction act;
    act.sa_flags = 0;
    act.sa_handler = myalarm;
    sigemptyset(&act.sa_mask); //清空临时阻塞信号集

    //注册信号捕捉
    sigaction(SIGALRM, &act, NULL);

    struct itimerval new_value;

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

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

    int ret = setitimer(ITIMER_REAL, &new_value, NULL);
    printf("定时器开始了\n");

    if(ret == -1){
        perror("setitimer");
        return -1;
    }
    while(1);

   // getchar();

    return 0;
}

 2.27 sigchld信号

/*
    SIGCHLD信号产生的3个条件:
        1.子进程结束
        2.子进程暂停了
        3.子进程继续运行
        都会给父进程发送该信号,父进程默认忽略该信号

    使用SIGCHILD信号解决僵尸进程问题
*/

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

void myFun(int num){
    printf("捕捉到的信号:%d\n", num);
    //回收子进程资源
    //wait(NULL);
    while(1){
        int ret = waitpid(-1, NULL, WNOHANG);
        if(ret > 0){
            printf("child die, pid = %d\n" ,ret);
        }
        else if(ret == 0){
            //说明还有子进程活着
            break;
        }
        else if(ret == -1){
            //没有子进程活着
            break;
        }
    }
}

int main(){

    //提前设置好阻塞信号集,阻塞SIGCHLD,以为有可能子进程很快结束,父进程还没有注册完信号捕捉
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGCHLD);
    sigprocmask(SIG_BLOCK, &set, NULL);

    //创建一些子进程
    pid_t pid;
    for(int i = 0; i < 20; ++i){
        pid = fork();
        if(pid == 0)
            break;
    }
    if(pid > 0){
        //父进程

        //捕捉子进程死亡时发出的SIGCHLD信号

        struct sigaction act;
        act.sa_flags = 0;
        act.sa_handler = myFun;
        sigemptyset(&act.sa_mask);
        sigaction(SIGCHLD, &act, NULL);

        //注册完信号捕捉以后解除阻塞
        sigprocmask(SIG_UNBLOCK, &set, NULL);

        while(1){
            printf("parent process pid = %d\n", getpid());
            sleep(2);
        }
    }
    else if(pid == 0){
        printf("child process pid = %d\n", getpid());
    }


    return 0;
}

2. 28 共享内存(1)

共享内存相关的函数
#include <sys/ipc.h>
#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);
    - 功能:创建一个新的共享内存段,或者获取一个既有的共享内存段的标识。
        新创建的内存段中的数据都会被初始化为0
    - 参数:
        - key : key_t类型是一个整形,通过这个找到或者创建一个共享内存。
                一般使用16进制表示,非0值
        - size: 共享内存的大小
        - shmflg: 属性
            - 访问权限
            - 附加属性:创建/判断共享内存是不是存在
                - 创建:IPC_CREAT
                - 判断共享内存是否存在: IPC_EXCL , 需要和IPC_CREAT一起使用
                    IPC_CREAT | IPC_EXCL | 0664
    - 返回值:
        失败:-1 并设置错误号
        成功:>0 返回共享内存的引用的ID,后面操作共享内存都是通过这个值。


void *shmat(int shmid, const void *shmaddr, int shmflg);
    - 功能:和当前的进程进行关联
    - 参数:
        - shmid : 共享内存的标识(ID),由shmget返回值获取
        - shmaddr: 申请的共享内存的起始地址,指定NULL,内核指定
        - shmflg : 对共享内存的操作
            - 读 : SHM_RDONLY, 必须要有读权限
            - 读写: 0
    - 返回值:
        成功:返回共享内存的首(起始)地址。  失败(void *) -1


int shmdt(const void *shmaddr);
    - 功能:解除当前进程和共享内存的关联
    - 参数:
        shmaddr:共享内存的首地址
    - 返回值:成功 0, 失败 -1

int shmctl(int shmid, int cmd, struct shmid_ds *buf);
    - 功能:对共享内存进行操作。删除共享内存,共享内存要删除才会消失,创建共享内存的进行被销毁了对共享内存是没有任何影响。
    - 参数:
        - shmid: 共享内存的ID
        - cmd : 要做的操作
            - IPC_STAT : 获取共享内存的当前的状态
            - IPC_SET : 设置共享内存的状态
            - IPC_RMID: 标记共享内存被销毁
        - buf:需要设置或者获取的共享内存的属性信息
            - IPC_STAT : buf存储数据
            - IPC_SET : buf中需要初始化数据,设置到内核中
            - IPC_RMID : 没有用,NULL

key_t ftok(const char *pathname, int proj_id);
    - 功能:根据指定的路径名,和int值,生成一个共享内存的key
    - 参数:
        - pathname:指定一个存在的路径
            /home/nowcoder/Linux/a.txt
            / 
        - proj_id: int类型的值,但是这系统调用只会使用其中的1个字节
                   范围 : 0-255  一般指定一个字符 'a'

2.29 共享内存(2)

 

问题1:操作系统如何知道一块共享内存被多少个进程关联?
    - 共享内存维护了一个结构体struct shmid_ds 这个结构体中有一个成员 shm_nattch
    - shm_nattach 记录了关联的进程个数

问题2:可不可以对共享内存进行多次删除 shmctl
    - 可以的
    - 因为shmctl 标记删除共享内存,不是直接删除
    - 什么时候真正删除呢?
        当和共享内存关联的进程数为0的时候,就真正被删除
    - 当共享内存的key为0的时候,表示共享内存被标记删除了
        如果一个进程和共享内存取消关联,那么这个进程就不能继续操作这个共享内存。也不能进行关联。

    共享内存和内存映射的区别
    1.共享内存可以直接创建,内存映射需要磁盘文件(匿名映射除外)
    2.共享内存效果更高
    3.内存
        所有的进程操作的是同一块共享内存。
        内存映射,每个进程在自己的虚拟地址空间中有一个独立的内存。
    4.数据安全
        - 进程突然退出
            共享内存还存在
            内存映射区消失
        - 运行进程的电脑死机,宕机了
            数据存在在共享内存中,没有了
            内存映射区的数据 ,由于磁盘文件中的数据还在,所以内存映射区的数据还存在。

    5.生命周期
        - 内存映射区:进程退出,内存映射区销毁
        - 共享内存:进程退出,共享内存还在,标记删除(所有的关联的进程数为0),或者关机
            如果一个进程退出,会自动和共享内存进行取消关联。
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

int main(){

    //1.创建一个共享内存
    int shmid = shmget(100, 4096, IPC_CREAT | 0664);
    printf("shmid = %d\n", shmid);
    //2.和当前进程进行关联
    void *ptr = shmat(shmid, NULL, 0);
    //3.写数据
    char *str = "helloworld";
    memcpy(ptr, str, strlen(str));

    printf("按任意键继续\n");
    getchar();

    //4.解除关联
    shmdt(ptr);
    //5.删除共享内存
    shmctl(shmid, IPC_RMID, NULL);


    return 0;
}
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

int main(){

    //1.获取一个共享内存
    int shmid = shmget(100, 0, IPC_CREAT);
    printf("shmid = %d\n", shmid);
    //2.和当前进程进行关联
    void *ptr = shmat(shmid, NULL, 0);
    //3.读数据
    printf("%s\n", (char *)ptr);

    printf("按任意键继续\n");
    getchar();

    //4.解除关联
    shmdt(ptr);
    //5.删除共享内存
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

2.30 守护进程(1)

2.31 守护进程(2)

/*
    写一个守护进程,每隔2s获取一下系统时间,将这个时间写入磁盘文件中。
*/

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


void work(int num){
    //捕捉到信号之后,获取系统时间,写入磁盘文件
    time_t tm = time(NULL);
    struct tm *loc = localtime(&tm);
    // char buf[1024];
    // sprintf(buf, "%d-%d-%d %d:%d:%d\n", loc->tm_year, loc->tm_mon, loc->tm_mday, loc->tm_hour, loc->tm_min,
    //     loc->tm_sec);
    // printf("%s\n", buf);
    char *str = asctime(loc);
    int fd = open("time.txt", O_CREAT | O_RDWR | O_APPEND, 0664);
    write(fd, str, strlen(str));
    close(fd);
}

int main(){

    //1.创建子进程,退出父进程
    pid_t pid = fork();
    if(pid > 0){
        exit(0);
    }
    //2.将子进程重新创建一个会话
    setsid();
    //3.设置掩码
    umask(022);
    //4.更改工作目录
    chdir("/home/nowcoder/");
    //5.关闭、重定向文件描述符
    int fd = open("/dev/null", O_RDWR);
    dup2(fd, STDIN_FILENO);
    dup2(fd, STDOUT_FILENO);
    dup2(fd, STDERR_FILENO);
    
    //6.业务逻辑

    //捕捉定时信号
    struct sigaction act;
    act.sa_flags = 0;
    act.sa_handler = work;
    sigemptyset(&act.sa_mask);
    sigaction(SIGALRM, &act, NULL);

    //创建定时器
    struct itimerval val;
    val.it_value.tv_sec = 2;
    val.it_value.tv_usec = 0;
    val.it_interval.tv_sec = 2;
    val.it_interval.tv_usec = 0;
    setitimer(ITIMER_REAL, &val, NULL);
    
    //不让进程结束
    while(1){
        sleep(10);
    }


    return 0;
}

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值