Linux - 进程

已于 2023-07-20 11:01:59 修改
阅读量100 收藏
点赞数 1
分类专栏： webSever Lern 文章标签： linux 运维 服务器
于 2023-07-15 15:12:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44736340/article/details/131738630
版权

命令：

  • ps aux/ajx
  • top
  • kill -sigkill/-9 name            kill -l 
  • GDB
    • set follow-fork-mode [parent（默认）| child]
    • set detach-on-fork [on | off]
    • info inferiors
    • inferior id
    • detach inferiors id

 函数：

  • pid_t getpid(void);

一、进程概述

1.程序和进程

（1）程序

（2）进程

 2.进程控制块PCB

 

 二、进程状态转换

1.进程的状态

（1）三态

（2）五态

2.进程相关命令

（1）ps aux/ajx

（2）STAT参数 

（3）top 实时显示进程动态

（4）kill  杀死进程 

3.进程号和相关函数

三、进程的创建

1.进程创建

父子进程之间的关系：
        区别：
            1.fork()函数的返回值不同
                父进程中: >0 返回的子进程的ID
                子进程中: =0
            2.pcb中的一些数据
                当前的进程的id pid
                当前的进程的父进程的id ppid
                信号集

        共同点：
            某些状态下：子进程刚被创建出来，还没有执行任何的写数据的操作
                - 用户区的数据
                - 文件描述符表

父子进程对变量是不是共享的？
            - 刚开始的时候，是一样的，共享的。如果修改了数据，不共享了。
            - 读时共享（子进程被创建，两个进程没有做任何的写的操作），写时拷贝。

        实际上，更准确来说，Linux 的 fork() 使用是通过写时拷贝 (copy- on-write) 实现。
        写时拷贝是一种可以推迟甚至避免拷贝数据的技术。
        内核此时并不复制整个进程的地址空间，而是让父子进程共享同一个地址空间。
        只有在需要写入的时候才会复制地址空间，从而使各个进行拥有各自的地址空间。其中的局部变量互不干扰。
        也就是说，资源的复制是在需要写入的时候才会进行，在此之前，以只读方式共享。

注意：fork之后父子进程共享文件，
fork产生的子进程与父进程相同的文件文件描述符指向相同的文件表，引用计数增加，共享文件偏移指针。

2.GDB多进程调试  

四、exec（）函数族 

1.介绍

一般使用方法：

        首先fork() 创建一个子进程，子进程执行exec("a.out")命令，然后子进程从a.out的main()函数开始执行；

        进程调用exec(“a.out")函数，内核区数据不变，用户区数据被替换为a.out的用户区数据

2.exec函数族 

(1)execl()

    #include <unistd.h>
    int execl(const char *path, const char *arg, ...);
        - 参数：
            - path:需要指定的执行的文件的路径
                a.out /home/nowcoder/a.out 推荐使用绝对路径
                ./a.out hello world

            - arg:是执行可执行文件所需要的参数列表
                第一个参数一般没有什么作用，为了方便，一般写的是执行的程序的名称
                从第二个参数开始往后，就是程序执行所需要的的参数列表。
                参数最后需要以NULL结束（哨兵）

        - 返回值：
            只有当调用失败，才会有返回值，返回-1，并且设置errno
            如果调用成功，没有返回值。调用成功，则代码区被替换，其中没有execl()函数了，所以没有返回值。

execl("/bin/ps", "ps", "aux", NULL);

示例：

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

int main() {

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

    if(pid > 0) {
        // 父进程
        printf("i am parent process, pid : %d\n",getpid());
        sleep(1);
    }else if(pid == 0) {
        // 子进程
        execl("hello","hello",NULL);

        //execl("/bin/ps", "ps", "aux", NULL);
        //perror("execl");
        printf("i am child process, pid : %d\n", getpid());

    }

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


    return 0;
}

2.execlp()

    #include <unistd.h>
    int execlp(const char *file, const char *arg, ... );
        - 会到环境变量中查找指定的可执行文件，如果找到了就执行，找不到就执行不成功。
        - 参数：
            - file:需要执行的可执行文件的文件名
                a.out
                ps

execlp("ps", "ps", "aux", NULL);

3.其它

        int execv(const char *path, char *const argv[]);
            -argv是需要的参数的一个字符串数组
        char * argv[] = {"ps", "aux", NULL};
        execv("/bin/ps", argv);


        int execve(const char *filename, char *const argv[], char *const envp[]);
        char * envp[] = {"/home/nowcoder", "/home/bbb", "/home/aaa"};

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

1.进程退出

标准C库：

        #include <stdlib.h>
        void exit(int status);
调用退出处理函数，刷新IO缓冲，关闭文件描述符，然后调用_exit()，
Linux系统:
        #include <unistd.h>
        void _exit(int status);

 2.孤儿进程（orphan）

3.僵尸进程(zombie)

六、进程回收 

 1.wait()

    #include <sys/types.h>
    #include <sys/wait.h>
    pid_t wait(int *wstatus);
        功能：等待任意一个子进程结束，如果任意一个子进程结束了，wait()函数会回收子进程的资源。
        参数：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个子进程
    fork()在父进程中返回子进程号，在子进程中返回0
    for(int i = 0; i < 5; i++) {
        pid = fork();
        //父进程创建的子进程在fork()之后继续执行；在子进程中，fork()返回0
        if(pid == 0) {
            //pid==0说明当前是子进程，跳出循环，避免子进程继续创建子进程
            //注意：子进程中fork()返回值并不是子进程的进程号
            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)
}

 2.waitpid()

    #include <sys/types.h>

    #include <sys/wait.h>

    pid_t waitpid(pid_t pid, int *wstatus, int options);

        功能：回收指定进程号的子进程，可以设置是否阻塞。

        参数：

            - pid:

                pid > 0 : 某个子进程的pid

                pid = 0 : 回收当前进程组的所有子进程    

                pid = -1 : 回收所有的子进程，相当于 wait()  （最常用）

                pid < -1 : pid绝对值为某个进程组的组id，回收指定进程组中的子进程

            - options：设置阻塞或者非阻塞

                0 : 阻塞

                WNOHANG : 非阻塞

            - 返回值：

                > 0 : 返回子进程的id

                = 0 : options=WNOHANG, 表示还有子进程活着

                = -1 ：错误，或者没有子进程了

七、进程间通信 

1.概念

2.Linux进程间通信的方式

3.匿名管道

4.管道的特点

5.为什么可以使用管道进行进程间通信

6.管道的数据结构

7.匿名管道的使用

   #include <unistd.h>

    int pipe(int pipefd[2]);

        功能：创建一个匿名管道，用来进程间通信。

        参数：int pipefd[2] 文件描述符，这个数组是一个传出参数。

            pipefd[0] 对应的是管道的读端

            pipefd[1] 对应的是管道的写端

        返回值：

            成功 0

            失败 -1

    管道默认是阻塞的：如果管道中没有数据，read阻塞，如果管道满了，write阻塞

    注意：匿名管道只能用于具有关系的进程之间的通信（父子进程，兄弟进程）

 示例1：父子进程通信（read、write）

// 子进程发送数据给父进程，父进程读取到数据输出
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(){

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

    //创建子进程
    pid_t pid = fork();
    if(pid>0){
        //父进程

        //关闭写端
        close(pipefd[1]);

        char buf[1024];
        while(1){
            int len = read(pipefd[0],buf,sizeof(buf));  //需要给定缓冲区大小
            printf("parent receive: %s ,pid: %d\n",buf,getpid());

            // char * str = "i am parent";      //" "字符串为const char *
            // write(pipefd[1],str,strlen(str));
            // sleep(1);
        }
        
    }else if(pid == 0){
        //子进程

        //关闭读端
        close(pipefd[0]);

        char buf[1024];
        while(1){
            char * str = "i am child";      //" "字符串为const char *
            write(pipefd[1],str,strlen(str));
            //sleep(1);

            // int len = read(pipefd[0],buf,sizeof(buf));  //需要给定缓冲区大小
            // printf("child receive: %s ,pid: %d\n",buf,getpid());
        }
    }

    return 0;
}

示例2：实现 ps aux | grep xxx 

     实现 ps aux | grep xxx 父子进程间通信

   

    子进程： ps aux, 子进程结束后，将数据发送给父进程

    父进程：获取到数据，过滤

   

    子进程将标准输出 stdout_fileno 重定向到管道的写端。  

    //创建管道

    int pipe(int pipefd[2]);

    //在进程中调用指定可执行文件

    //execlp()执行成功不会返回；如果调用失败，返回-1，从原程序调用点接着往下执行

    int execlp(const char *file, const char *arg, ... );    

    //重定向文件描述符   new指向old

    int dup2(int old,int new);      

#include <unistd.h>
#include <sys/types.h>
#include <stdio.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 = -1;
        while((len = read(fd[0], buf, sizeof(buf) - 1)) > 0) {
            // 过滤数据输出
            printf("%s", buf);
            memset(buf, 0, 1024);   //清空数据
        }
         //回收子进程资源
        wait(NULL);    

    } else if(pid == 0) {
        // 子进程
        // 关闭读端
        close(fd[0]);

        // 文件描述符的重定向 stdout_fileno -> fd[1]   
        //否则，ps命令会将结果出到终端
        dup2(fd[1], STDOUT_FILENO);
        //执行ps命令，参数为aux
        execlp("ps", "ps", "aux", NULL);   
        //execlp()执行成功不会返回；如果调用失败，返回-1，从原程序调用点接着往下执行 
        perror("execlp");
        exit(0);
    } else {
        //创建管道失败
        perror("fork");
        exit(0);
    }

    return 0;
}

8.管道的读写特点

管道的读写特点：
        使用管道时，需要注意以下几种特殊的情况（假设都是阻塞I/O操作）

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

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

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

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

总结：（假设都是阻塞I/O操作）
    读管道：
                管道中有数据，read返回实际读到的字节数。
                管道中无数据：
                    写端被全部关闭，read返回0（相当于读到文件的末尾）
                    写端没有完全关闭，read阻塞等待

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

设置管道读非阻塞：

    int flags = fcntl(fd[0], F_GETFL);          // 获取原来的flag

    flags |= O_NONBLOCK;                        // 修改flag的值   变为非阻塞

    fcntl(fd[0], F_SETFL, flags);                 // 设置新的flag

9.有名管道（FIFO） 

（1）概念

 （2）有名管道的使用

 (3)示例：两个不相关进程间通信

write.c

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

// 向管道中写数据
int main() {

    // 1.判断文件是否存在
    int ret = access("test", F_OK);
    if(ret == -1) {
        printf("管道不存在，创建管道\n");
        
        // 2.创建管道文件
        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);    //向buf写数据
        printf("write data : %s\n", buf);
        write(fd, buf, strlen(buf));
        sleep(1);
    }

    close(fd);

    return 0;
}

read.c 

// 从管道中读取数据
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("recv buf : %s\n", buf);
    }

    close(fd);

    return 0;
}

(4)注意事项

有名管道的注意事项：
        1.一个为只读而打开一个管道的进程会阻塞，直到另外一个有写权限的进程打开管道
        2.一个为只写而打开一个管道的进程会阻塞，直到另外一个有读权限的进程打开管道

    读管道：
        管道中有数据，read返回实际读到的字节数
        管道中无数据：
            管道写端被全部关闭，read返回0，（相当于读到文件末尾）
            写端没有全部被关闭，read阻塞等待
    
    写管道：
        管道读端被全部关闭，进行异常终止（收到一个SIGPIPE信号）
        管道读端没有全部关闭：
            管道已经满了，write会阻塞
            管道没有满，write将数据写入，并返回实际写入的字节数。

10、有名管道——实现简单聊天功能 

（1）概要

 （2）示例1：简单版（轮流发送一条消息）

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

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

    ret = access("fifo2",F_OK);
    if(ret == -1){
        printf("管道不存在,创建对应有名管道fifo2\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");

    char buf[128];
    //4.循环写读数据
    while(1){
        //清空数据
        memset(buf,0,128);
        printf("请输入：");
        //获取标准输入的数据
        fgets(buf,128,stdin);
        //写数据
        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){
            //ret=0,读完；ret=-1,调用失败
            perror("read");
            break;
        }
        printf("读到消息: %s\n",buf);
    }

    //5.关闭我呢见描述符
    close(fdr);
    close(fdw);
    
    return 0;
}
chatB.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>

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

    ret = access("fifo2",F_OK);
    if(ret == -1){
        printf("管道不存在,创建对应有名管道fifo2\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");

    char buf[128];
    //4.循环读写数据
    while(1){
        //读数据
        memset(buf,0,128);
        ret = read(fdr,buf,128);
        if(ret <= 0){
            //ret=0,读完；ret=-1,调用失败
            perror("read");
            break;
        }
        printf("读到消息: %s\n",buf);

        //清空数据
        memset(buf,0,128);
        printf("请输入：");
        //获取标准输入的数据
        fgets(buf,128,stdin);
        //写数据
        ret = write(fdw,buf,strlen(buf));
        if(ret == -1){
            perror("write");
            exit(0);
        }
    }

    //5.关闭我呢见描述符
    close(fdr);
    close(fdw);
    
    return 0;
}

（3）示例2：升级版（读写使用不同的进程，可连续发送多条消息）

结果

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

//fifo1  a写b读
//fifo2  a读b写

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

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

    //创建子进程
    //父进程写，子进程读
    pid_t pid = fork();

    if(pid>0){
        //printf("chatA父进程,只写\n");
        //父进程
        //以只写的方式打开fifo1
        int fdw = open("fifo1",O_WRONLY);
        if(fdw == -1){
            perror("open");
            exit(0);
        }
        printf("chatA打开fifo1成功,等待写入...\n");

        //循环写数据
        char buf[128];
        while(1){
            //清空数据
            memset(buf,0,128);
            //printf("请输入：");

            //获取标准输入的数据
            //=========fgets()读取一行字符串；当写完一行消息，按下回车后，fgets()执行结束，执行write();所以按下回车后输入的消息需要等待下一次循环读取=========
            //使用多进程后，chatB不断读取，所以chatA的写入不会阻塞
            fgets(buf,128,stdin);

            //写数据
            ret = write(fdw,buf,strlen(buf));
            if(ret == -1){
                perror("write");
                exit(0);
            }
        }

        close(fdw);
    }
    else if(pid == 0){
        //printf("chatA子进程，只读\n");
        //子进程
        //以只读的方式打开fifo2
        int fdr = open("fifo2",O_RDONLY);
        if(fdr == -1){
            perror("open");

            exit(0);
        }
        printf("chatA打开fifo2成功,等待读取...\n");

        char buf[128];
        while(1){
            //读数据
            memset(buf,0,128);
            ret = read(fdr,buf,128);
            if(ret <= 0){
                //ret=0,读完；ret=-1,调用失败
                perror("read");
                break;
            }
            printf("                    读到消息: %s",buf);
        }

        close(fdr);
    }
    
    return 0;
}
chatB.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>

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

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


    //创建子进程
    //父进程读，子进程写
    pid_t pid = fork();

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

        char buf[128];
        while(1){
            //读数据
            memset(buf,0,128);
            ret = read(fdr,buf,128);
            if(ret <= 0){
                //ret=0,读完；ret=-1,调用失败
                perror("read");
                break;
            }
            printf("                    读到消息: %s",buf);
        }

        close(fdr);
    }
    else if(pid==0){
        //printf("chatB子进程，只写\n");
        //子进程
        //以只写的方式打开fifo2
        int fdw = open("fifo2",O_WRONLY);
        if(fdw == -1){
            perror("open");
            exit(0);
        }
        printf("chatB打开fifo2成功,等待写入...\n");

        //循环写数据
        char buf[128];
        while(1){
            //清空数据
            memset(buf,0,128);
            //printf("请输入：");
            //获取标准输入的数据
            fgets(buf,128,stdin);
            //写数据
            ret = write(fdw,buf,strlen(buf));
            if(ret == -1){
                perror("write");
                exit(0);
            }
        }

        close(fdw);
    }
    
    return 0;
}
 注意：

        以只写方式打开文件会被阻塞，直到有读权限的进程打开文件。

        以只读方式打开文件不会被阻塞。

11.内存映射 

（1）概念

 （2）相关函数

 #include <sys/mman.h>

  void *mmp(void *addr, size_t length, int prot, int flags,int fd, off_t offset);

        - 功能：将一个文件或者设备的数据映射到内存中

        - 参数：

            - void *addr: NULL, 由内核指定

            - length : 要映射的数据的长度，这个值不能为0。建议使用文件的长度。

                        如果length<内存页的大小，系统自动分配一个页面的长度.

                    获取文件的长度：stat 或 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的权限要比open小)

                    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参数的值一样。

 （3）使用内存映射实现进程间通信

1.有关系的进程（父子进程）

        - 还没有子进程的时候

            - 通过唯一的父进程，先创建内存映射区

        - 有了内存映射区以后，创建子进程

        - 父子进程共享创建的内存映射区

   

    2.没有关系的进程间通信

        - 准备一个大小不是0的磁盘文件,进程分别对磁盘文件建立内存映射

        - 进程1 通过磁盘文件创建内存映射区

            - 得到一个操作这块内存的指针

        - 进程2 通过磁盘文件创建内存映射区

            - 得到一个操作这块内存的指针

        - 使用内存映射区通信

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

 示例：父子进程通信

#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.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){
        char buf[128];
        strcpy(buf,(char *)ptr);
        printf("read data: %s\n",buf);
    }else if(pid == 0){
        strcpy((char *)ptr,"ni hao a!!!!");
    }

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

    close(fd);
    
    return 0;
}

（4）内存映射注意事项

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 权限大于 fd

5.可以open的时候O_CREAT一个新文件来创建映射区吗?
    - 可以的，但是创建的文件的大小如果为0的话，肯定不行
    - 可以对新的文件进行扩展
        -off_t lseek(int fd,off_t offset,int whence);   //lseek(fd,100,SEEK_END);
        -int truncate(const char * path,off_t len);    //拓展文件至指定大小

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

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

(5)使用内存映射实现文件拷贝

思路：

        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);
    //内存映射
    void * ptr = mmap(NULL,len,PROT_READ | PROT_WRITE,MAP_SHARED,fd,0);
    if(ptr == MAP_FAILED){
        perror("mmap");
        exit(0);
    }

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

    //拓展新文件
    truncate("cpy.txt",len);
    // lseek(fd,len,SEEK_END);
    write(fd1," ",1);   //写入，使拓展生效
  
    // 3.对新文件进行内存映射
    void * ptr1 = mmap(NULL,len,PROT_READ | PROT_WRITE,MAP_SHARED,fd1,0);
    if(ptr1 == MAP_FAILED){
        perror("mmap");
        exit(0);
    }

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

    // 5.释放资源,释放顺序与申请顺序相反
    munmap(ptr1,len);
    munmap(ptr,len);

    return 0;
}

 （6）匿名映射

匿名映射：不需要文件实体的一个内存映射

    flag = MAP_SHARED | MAP_ANONYMOUS

    fd = -1

int len = 4096;

    void * ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);

2023.7.20 

ミ míＳs °
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Linux-进程
m0_52604787的博客
12-07 128
Linux支持 多进程 特性，可以最大化的使用cpu资源；用户可以在同一个cpu上运行多个用户程序。 多进程的原理是：时钟中断触发进程调度程序，调度程序分时运行多个进程。这就要求每个进程能够保留现场信息（cpu现场、系统资源、调度信息等）。 linux使用 进程描述符 task_struct数据结构记录现场信息，然后基于进程描述符管理进程，包括进程的创建、调度、消亡等操作。
linux-进程管理和常用命令
学无止境
02-28 9220
进程是已启动的可执行程序的运行实例，是程序运行的过程，动态的，有生命周期及运行状态。程序： 二进制文件，静态 /bin/date, /usr/sbin/httpd，/usr/sbin/sshd, /usr/sbin/nginx。
Linux--进程概念
includeevey的博客
11-22 4022
了解进程就从这里开始
Linux-查看进程
ccb1372098的博客
08-14 1809
Linux的简单介绍
linux-进程和线程
07-26
在Linux环境下进行C编程时，经常会面临一个问题，即需要同时处理多个任务。那么，在这种情况下，我们应该如何设计代码以实现多个任务的有序执行呢？本文旨在分享进程和线程编程基础知识，并与大家探讨在C语言中使用...
linux-进程与服务管理
05-21
linux进程与服务管理、进程介绍、服务进程管理实践、显示进程状态树
linux-进程调度
05-04
本文将深入探讨Linux进程调度的原理、策略以及相关概念。 首先，我们了解什么是进程。在计算机科学中，进程是程序在内存中的实例，拥有自己的独立资源，如内存空间、文件描述符等。每个进程都有一个唯一的进程ID...
三分钟速学linux-进程管理命令
01-09
linux进程命令一、ps -显示进程状态二、pstree – 以树状图显示进程三、pidof – 返回运行程序的进程ID四、 pgrep命令 – 用于检索当前正在运行的进程五、top命令 – 实时显示进程动态六、lsof – 查看进程文件七、...
linux--进程
10-04
理解Linux进程的概念、管理和控制对于深入理解操作系统的工作原理至关重要。本篇将详细介绍Linux进程的相关知识点。 一、进程定义 进程是计算机中正在运行的程序的实例，它是操作系统分配资源的基本单位。每个进程...
【Linux杂货铺】Linux学习之路：期末总结篇1
聆风吟的博客
06-28 1208
本文主要讲了作者本人期末复习时的总结，欢迎大家借鉴浏览。
深入了解Linux中的dnsmasq：配置与优化指南
小灰灰的博客
07-04 233
是一个轻量级的网络服务，主要用于提供DNS缓存和DHCP服务。它广泛应用于家庭路由器、网络服务器以及各种嵌入式设备中。本文将详细介绍如何在Linux系统中安装、配置和优化。可以通过包管理器轻松安装。：配置DHCP服务器的IP地址范围。：为特定MAC地址分配固定IP。在大多数Linux发行版中，，以提升网络性能和安全性。：设置DNS缓存条目数量。：指定上游DNS服务器。：防止DNS重绑定攻击。：为本地网络设置域名。：阻止特定域名的解析。在Linux系统中，：启用详细日志记录。
Linux——线程
最新发布
Tlzns的博客
07-04 323
Linux——线程
GNU/Linux - Kconfig Language - 2
guoqx的专栏
07-04 336
这对 Kconfig 文件编写者有一些影响。拥有定义明确的语义对于实际评估依赖关系的工具非常有用，例如，有一项工作就是用布尔抽象表达 Kconfig 的推断语义，将 Kconfig 逻辑转化为布尔公式，并在此基础上运行 SAT 求解器来查找死代码/死特征（始终处于非活动状态），使用这种方法在 Linux 中发现了 114 个死特征。为了避免向用户询问无法在用户编译内核的系统上使用的驱动程序，如果合理的话，控制驱动程序编译的配置符号应包含适当的依赖关系，将符号的可见性限制在驱动程序可使用的平台（超集）上。
Linux Swap机制关键点分析
GetnextWindow的专栏
06-30 332
参考文章：Linux Swap 从 userspace 到 kernel详解_kernel swap-CSDN博客Linux Swap 与 Zram 详解 - 泰晓科技一文聊透 Linux 缺页异常的处理—— 图解 Page Faults（下） - 简书
Puppy Linux-最小的操作系统-仍然在更新32位设备的支持
地球空间
06-28 739
Puppy Linux 是一个由多个 Linux 发行版组成的集合，它们建立在相同的共享原则之上，使用相同的一套工具构建，建立在一套独特的 Puppy 特定应用程序和配置之上，通常无论您选择哪种口味，都能提供一致的行为和功能。使用 Woof 构建的 Puppy Linux 发行版 → 为满足特定需求和外观而开发，也针对一般用途，使用 Puppy Linux 系统构建器（称为 Woof-CE）构建，带有一些附加或修改的软件包。多样性 → 数以百计的衍生版（"puplets"），其中之一肯定能满足您的需求。
Linux--V4L2应用程序开发（二）获取数据
qq_47258284的博客
06-28 681
ioctl VIDIOC_REQBUFS：申请buffer，APP可以申请很多个buffer，但是驱动程序不一定能申请到ioctl VIDIOC_QUERYBUF和mmap：查询buffer信息、映射如果申请到了N个buffer，这个ioctl就应该执行N次执行mmap后，APP就可以直接读写这些bufferioctl VIDIOC_QBUF：把buffer放入"空闲链表"如果申请到了N个buffer，这个ioctl就应该执行N次ioctl VIDIOC_STREAMON：启动摄像头。
Linux——/etc/passwd文件含义，grep，cut
nianwan2157的博客
06-30 595
基于“行”的方式来提取数据是比较简单的，只需要设置好要搜索的关键词即可，但如果按列搜索，不仅要使用-f参数来设置需要看的列数，还需要使用-d参数来设置间隔符号。[root@server ~]# grep -nv "/sbin/nologin" /etc/passwd （反向）grep -r h ./* 如果要明确搜索当前目录中的子目录有h的行。# 相当于 grep -n “/sbin/nologin” /etc/passwd | wc -l。
Linux/Ubuntu访问局域网共享文件夹
小叮当ing
07-04 98
文件夹中找到“Other Location”，输入“smb:IP地址/共享文件夹名称”，然后点击connect后者直接回车即可！
linux子进程映像的重新加载,Linux-进程虚拟地址空间中加载新映像（续进程基础）...
05-25
在Linux中，子进程的映像重新加载可以通过exec()函数来实现。exec()函数可以在当前进程的上下文中加载新的可执行文件，并替换当前进程的映像。这个过程本质上是一个映像的卸载和加载过程，即先将旧的映像卸载，然后...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值