第2章 Linux多进程开发 10~进程间通信

已于 2023-02-19 18:02:23 修改
阅读量377 收藏 1
点赞数 1
分类专栏： C++开发后端基础知识 文章标签： linux c++ 运维
于 2022-10-27 20:48:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IS_MOKE/article/details/127546395
版权

目录

10 进程间通信

01 / 进程间通讯概念

在这里插入图片描述

02 / Linux 进程间通信的方式

在这里插入图片描述

03 / 匿名管道

在这里插入图片描述
“|” 管道符

04 / 管道的特点

在这里插入图片描述

匿名管道用在有关系之间的进程（父子进程）中，有名管道用在没有关系的进程中。

在这里插入图片描述

05 / 为什么可以使用管道进行进程间通信

在这里插入图片描述
因为fork出来的文件描述符指向同一个文件

06 / 管道的数据结构

在这里插入图片描述
管道是环形队列！！！

07 / 匿名管道的使用

在这里插入图片描述
在这里插入图片描述
pipe size:8*512=4K

#include <unistd.h>
#include <sys/types.h>
#include <stdio.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);

    return 0;
}

在这里插入图片描述
在这里插入图片描述

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

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

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

// 子进程发送数据给父进程，父进程读取到数据输出
#include <unistd.h>
#include <sys/types.h>
#include <stdio.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("i am parent process, pid : %d\n", getpid());

        // 关闭写端
        close(pipefd[1]);
        
        // 从管道的读取端读取数据
        char buf[1024] = {0};
        while(1) {
            int len = read(pipefd[0], buf, sizeof(buf));
            printf("parent recv : %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("i am 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(1);

            // int len = read(pipefd[0], buf, sizeof(buf));
            // printf("child recv : %s, pid : %d\n", buf, getpid());
            // bzero(buf, 1024);
        }
        
    }
    return 0;
}

管道的读写特点：

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

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

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

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

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

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

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

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
/*
    设置管道非阻塞
    int flags = fcntl(fd[0], F_GETFL);  // 获取原来的flag
    flags |= O_NONBLOCK;            // 修改flag的值
    fcntl(fd[0], F_SETFL, flags);   // 设置新的flag
*/
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("i am parent process, pid : %d\n", getpid());

        // 关闭写端
        close(pipefd[1]);
        
        // 从管道的读取端读取数据
        char buf[1024] = {0};

        int flags = fcntl(pipefd[0], F_GETFL);  // 获取原来的flag
        flags |= O_NONBLOCK;            // 修改flag的值
        fcntl(pipefd[0], F_SETFL, flags);   // 设置新的flag

        while(1) {
            int len = read(pipefd[0], buf, sizeof(buf));
            printf("len : %d\n", len);
            printf("parent recv : %s, pid : %d\n", buf, getpid());
            memset(buf, 0, 1024);
            sleep(1);
        }

    } else if(pid == 0){
        // 子进程
        printf("i am 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;
}

08 / 有名管道

在这里插入图片描述

在这里插入图片描述
unlink删除一个文件

在这里插入图片描述
在这里插入图片描述

阻塞了
fifo里的数据都保存在内存，一旦程序关掉，就没有数据了

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>

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

    读管道：
        管道中有数据，read返回实际读到的字节数
        管道中无数据：
            管道写端被全部关闭，read返回0，（相当于读到文件末尾）
            写端没有全部被关闭，read阻塞等待
    
    写管道：
        管道读端被全部关闭，进行异常终止（收到一个SIGPIPE信号）
        管道读端没有全部关闭：
            管道已经满了，write会阻塞
            管道没有满，write将数据写入，并返回实际写入的字节数。
*/
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);
    }
    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 data : %s\n", buf);
        write(fd, buf, strlen(buf));
        sleep(1);
    }

    close(fd);

    return 0;
}

在这里插入图片描述

read.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.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("recv buf : %s\n", buf);
    }

    close(fd);

    return 0;
}

在这里插入图片描述
在这里插入图片描述
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("管道不存在，创建对应的有名管道\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");

    char buf[128];

    // 4.循环的写读数据
    while(1) {
        memset(buf, 0, 128);
        // 获取标准输入的数据
        fgets(buf, 128, stdin);
        // 写数据
        ret = write(fdw, buf, strlen(buf));
        if(ret == -1) {
            perror("write");
            exit(0);
        }

        // 5.读管道数据
        memset(buf, 0, 128);
        ret = read(fdr, buf, 128);
        if(ret <= 0) {
            perror("read");
            break;
        }
        printf("buf: %s\n", buf);
    }

    // 6.关闭文件描述符
    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("管道不存在，创建对应的有名管道\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");

    char buf[128];

    // 4.循环的读写数据
    while(1) {
        // 5.读管道数据
        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);
        // 写数据
        ret = write(fdw, buf, strlen(buf));
        if(ret == -1) {
            perror("write");
            exit(0);
        }
    }

    // 6.关闭文件描述符
    close(fdr);
    close(fdw);

    return 0;
}

在这里插入图片描述

在这里插入图片描述

10 / 内存映射

在这里插入图片描述

父子进程间

/*
    #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 ：可执行的权限
                -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:读写
	总结：prot权限必须小于open权限
            - offset：偏移量，一般不用。必须指定的是4k的整数倍，0表示不便宜。
        - 返回值：返回创建的内存的首地址
            失败返回MAP_FAILED，(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 <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) {
        wait(NULL);
        // 父进程
        char buf[64];
        strcpy(buf, (char *)ptr);
        printf("read data : %s\n", buf);
       
    }else if(pid == 0){
        // 子进程
        strcpy((char *)ptr, "nihao a, son!!!");
    }

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

    return 0;
}

两个非亲缘进程间

process1

/*
 2.没有关系的进程间通信
        -准备一个大小不是0的磁盘文件
        -进程1通过磁盘文件创建内存映射区
            -得到一个操作这块内存的指针
        -进程2通过磁盘文件创建内存映射区
            -得到一个操作这块内存的指针
        -使用内存映射区通信

*/

#include <stdio.h>
#include <sys/mman.h>
#include <string.h>

//open
#include <fcntl.h>
#include <sys/stat.h> 
//#include <sys/types.h>

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

int main(){

    int fd = open("a.txt", O_RDWR);

    int size = lseek(fd, 0, SEEK_END);

    void *ptr = mmap(NULL, size, PROT_WRITE|PROT_READ, MAP_SHARED, fd, 0);
                    //位置 大小 权限 是否同步 文件 偏移量

    strcpy((char *)ptr, "hello, this is process 1......");

    munmap(ptr, size);

    return 0;
}

process2

#include <stdio.h>
#include <sys/mman.h>
#include <string.h>

//open
#include <fcntl.h>
#include <sys/stat.h> 
//#include <sys/types.h>

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

//wait()
#include <wait.h>

int main(){

    int fd = open("a.txt", O_RDWR);

    int size = lseek(fd, 0, SEEK_END);

    void *ptr = mmap(NULL, size, PROT_WRITE|PROT_READ, MAP_SHARED, fd, 0);
                    //位置 大小 权限 是否同步 文件 偏移量

    wait(NULL);
    char buf[64];
    strcpy(buf, (char *)ptr);
    printf("process 2: %s \n", buf);

    munmap(ptr, size);

    return 0;
}

思考问题

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
越界操作操作的是非法的内存 -> 段错误

复制文件

内存操作很快！

copy.c

// 使用内存映射实现文件拷贝的功能：对于文件大小较小时
/*
    思路：
        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;
}

在这里插入图片描述

mmap_anon.c

/*
    匿名映射：不需要文件实体进程一个内存映射
*/

#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>
#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-进程间通信
AI_ELF的博客
08-23 6904
数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
Linux多进程详解（进程间通信）
qq_43710269的博客
06-09 2915
Linux多进程详解，并行并发，fork,exec，进程间通信，匿名管道通信，有名管道通信，内存映射，共享内存通信，信号通信，信号集
Linux 0.11-硬盘其他部分挪入内存-04
m0_53157173的博客
11-06 342
之后真正进入操作系统内核后，中断处理程序是需要我们自己去重新写的，这个在后面的章节中，你会不断看到各个模块注册自己相关的中断处理程序，所以不要急。，一个字节都不能偏，就是这么强耦合，需要小心翼翼，需要大脑时刻保持清醒，规划好自己写的代码被编译并存储在硬盘的哪个位置，而随后又会被加载到内存的哪个位置，不能错乱。好了，到目前为止，你是不是觉得，我去，这前面编译放在硬盘的位置，和后面代码写死的跳转地址，竟然如此地强耦合？书接上回，上回书咱们说到，操作系统的一些最最最最基础的准备工作，已经准备好了。
2-17 内存映射
weixin_44671576的博客
11-14 323
内存映射是将磁盘文件中的数据映射到内存，用户通过修改内存来修改磁盘； 调用相关信息： #include <sys/mman.h> void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset); - 功能：将一个文件或者设备的数据映射到内存中 - 参数： - void *addr: NULL, 由内核指定
深入探索Linux系统编程：dlfcn.h、sys/mman.h和sys/
最新发布
qq_44103359的博客
04-22 838
通过本文的详细讲解和实例演示，我们可以看到dlfcn.h、sys/mman.h和sys/stat.h在Linux系统编程中的作用和用法。这三个头文件分别提供了动态链接、内存管理和文件状态信息查询的功能，对于进行系统编程的开发者来说，掌握这三个头文件的使用是非常重要的。随着技术的不断进步，我们有理由相信，这三个头文件将在未来发挥更大的作用，为开发者提供更加高效和便捷的系统编程解决方案。
Linux 头文件详解
Sunshine
04-24 1203
Linux 头文件详解 概览： 头文件目录中总共有32个.h头文件。其中主目录下有13个，asm子目录中有4个，Linux子目录中有10个，sys子目录中有5个。 <a.out.h>：a.out头文件，定义了a.out执行文件格式和一些宏。 <const.h>：常数符号头文件，目前仅定义了i节点中i_mode字段的各标志位。 <ctype.h>：字符类...
Linux系统编程——内存映射
欲盖弥彰1314
07-02 599
内存映射优点 与普通文件多写相比能加快读文件/设备的读写速度 文件映射 创建文件映射步骤： 1、使用open()获取文件描述符fd 2、将文件描述符fd作为fd参数给mmap() 调用mmap()后及时关闭文件描述fd，也不会对映射产生任何影响 创建映射 #include <sys/mman.h> void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset); addr —— 要映射的虚拟内存
嵌入式Linux应用程序开发详解第8章进程间通信_linux_
10-02
这一章节详细探讨了在Linux环境下如何实现有效的进程间通信，这对于开发高效、稳定的嵌入式应用至关重要。下面将深入阐述相关知识点。 一、进程间通信概述 进程间通信是指在不同进程之间传递信息或同步操作，以实现...
Linux进程间通信--使用信号
09-15
Linux进程间通信是一种让不同进程之间交换信息或协调工作的方式，而在Linux系统中，信号（Signal）是一种简单但重要的通信机制。本文将深入探讨如何利用信号进行进程间通信。 首先，信号是操作系统用来通知进程发生...
实验 Linux进程通信的参考答案
07-05
实验 Linux 进程通信的参考答案展示了 Linux 中进程通信的机制和方式，包括信号机制、管道通信机制和多进程并发执行。这些机制和方式是 Linux 编程中非常重要的概念，了解它们对于编写高效、可靠的程序非常重要。
linux中的mprotect()函数：set protection on a region of memory
谢白羽
08-18 808
文章目录1.头文件2.函数作用3.函数及参数描述4.示例代码 1.头文件 #include <sys/mman.h> 2.函数作用 1.mprotect() changes protection for the calling process’s memory page(s) containing any part of the address range in the interval [addr, addr+len-1]. addr must be aligned to a page
course2610_lab19虚存映射mmap()及读写性能探究（上）
chumingqian的博客
05-19 1043
虚拟内存系统通过将虚拟内存分割为称作虚拟页(Virtual Page，VP)大小固定的块，一般情况下，每个虚拟页的大小默认是4096字节。 同样的，物理内存也被分割为物理页(Physical Page，PP)，也为4096字节。 背景 在研发分布式日志存储系统，基于Raft协议的自研分布式日志存储系统，Logstore则是底层存储引擎。 Logstore中，使用mmap对数据文件进行读写。Logstore的存储结构简化如下图： Logstore使用了Segments Files + Index F.
C++共享内存实现（windows和linux）
热门推荐
踏莎行的博客
08-27 1万+
共享内存是一种进程间通信的方式，速度比较快 基本原理：以页面为单位，将一个普通文件映射到内存中，达到共享内存和节约内存的目的，通常在需要对文件进行频繁读写时使用，这样用内存读写取代I/O读写,以获得较高的性能 windows和linux都提供了原生的系统级的C++接口，可以将文件映射到内存 windows中使用CreateFileMapping linux使用mmap 代码示例 这里...
mmap函数用法及示例程序
nancygreen的专栏
06-21 1万+
UNIX网络编程第二卷进程间通信对mmap函数进行了说明。该函数主要用途有三个：1、将一个普通文件映射到内存中，通常在需要对文件进行频繁读写时使用，这样用内存读写取代I/O读写，以获得较高的性能；2、将特殊文件进行匿名内存映射，可以为关联进程提供共享内存空间；3、为无关联的进程提供共享内存空间，一般也是将一个普通文件映射到内存中。头文件：   #include
mmap方法将文件映射到内存
Leeboy_Wang的专栏
08-22 5987
注意：sys/mman.h头文件在windows下没有必须在linux下才能通过。 方法介绍： mmap将一个文件或者其它对象映射进内存。文件被映射到多个页上，如果文件的大小不是所有页的大小之和，最后一个页不被使用的空间将会清零。 void *mmap(void *start, size_t length, int prot, int flags,int fd, off_t offset);
Linux--共享内存mmap函数
loreal8的博客
06-19 392
共享内存mmap函数 #include <sys/mman.h> void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset); //参数一：要映射的地址，不知道就写NULL去让系统选择 //参数二：映射的大小 //参数三：保护的方式有读，写，执行，空 PROT_READ PROT_WRITE PROT_EXEC PROT_NONE //参数四：标志位
linux下硬件驱动调用步骤,Linux硬件设备访问
weixin_36313743的博客
05-13 1042
一、mmap设备操作1、mmap系统调用void *mmap(void * addr, size_t len, int prot, int flags, int fd, off_t offset)返回值：内存映射的首地址(虚拟映射区首地址)。功能：内存映射函数mmap，负责把文件内容映射到进程的虚拟内存空间，通过对这段内存的读取和修改(使用指针)，来实现对文件的读取和修改，而不需要再调用read，...
Linux文件操作（三）
03-28 4089
mkdir和rmdir我们可以使用mkdir和rmdir来创建和移除目录.其语法如下:#include int mkdir(const char *path, mode_t mode);mkdir系统调用可以用来创建目录,而这是与mkdir程序相等同的.mkdir以path为名字创建一个新的目录.目录的权限是由参数mode来指定的,而这也与open系统调用中的O_CREAT的选项是一样的,而且这也
linux常用头文件
almo_omla的博客
06-29 598
1、 Linux中一些头文件的作用： assert.h：ANSI C。提供断言，assert(表达式)glib.h：GCC。GTK，GNOME的基础库，提供很多有用的函数，如有数据结构操作函数。使用glib只需要包含glib.hdirent.h：GCC。文件夹操作函数。struct dirent,struct DIR,opendir(),closedir(),readdir(),readdir64
嵌入式Linux：进程间通信详解
"《嵌入式Linux应用程序开发标准教程》第8章——进程间通信，讲解了Linux系统中进程通信的各种方法，包括管道、有名管道、消息队列、共享内存等，介绍了UNIX、SystemV和Posix的IPC机制，并重点讨论了在Linux环境下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值