Linux进程间通信

最新推荐文章于 2024-06-18 20:43:02 发布
最新推荐文章于 2024-06-18 20:43:02 发布
阅读量151 收藏
点赞数
分类专栏： 笔记 Linux 文章标签： 嵌入式 多线程 多进程 内核 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kksdw/article/details/105595280
版权

嵌入式Linux多任务：进程，线程
单任务：一个任务执行完毕之后，下个任务才能执行
多任务：任务的执行可以被中断，中断之后可以执行其他任务（并发，并行）
单核CPU:并发
多核CPU:并发，并行
进程实现多任务：特点：给每个进程分配独立的地址空间，4G大小（1G内核，3G用户空间）
进程创建方式：fork>exec函数族>system>vfork
进程的退出：exit()库函数/清理缓冲
-exit()系统调用/不清理缓冲
进程的等待：wait();解决僵尸进程

学习目标：学会创建多任务进程

进程间通信（IPC）方式

广义上进程间的通信
进程——文件——进程
进程——数据库——进程
例如下面代码所示（通过文件进行通信）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()
{
    pid_t pid;
``  pid = fork();

    if (pid == -1)
    {
        perror("fork error!");
        exit(1);
    }

    if (pid == 0)
    {
        //普通文件
        int fd = open("b.txt", O_CREAT | O_WRONLY, 0655);
        if (fd == -1)
        {
            perror("open file error!");
            exit(1);
        }

        char buf[100] = "hello world";

        write(fd, buf, strlen(buf));

        close(fd);`
    }
    else if (pid > 0)
    {
        sleep(1);
        int fd = open("b.txt", O_RDONLY);
        if (fd == -1)
        {
            perror("open file error!");
            exit(1);
        }

        char buf[100] = {0};

        read(fd, buf, sizeof(buf));

        printf("rec buf = %s\n",buf);

        close(fd);
        return 0;
}

狭义上进程间的通信
分为：管道，信号，消息队列，共享内存，信号量，套接字

管道

无名管道：只允许父子进程间通信
API： int pipe(int pipefd[2]);

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

int main()
{
    pid_t pid;
    int fd[2];
    if (pipe(fd) < 0)
    {
        perror("pipe fork error!");
        exit(1);
    }
    pid = fork();
    if (pid == -1)
    {
        perror("fork error!");
        exit(1);
    }
    if (pid == 0)
    {
    //无名管道
        close(fd[0]);
        char buf[100];
        while (1)
        {
            scanf("%s", buf);
            write(fd[1], buf, strlen(buf));
        }
     }
    else if (pid > 0)
    { 
    char buf[100] = {0};
        while (1)
        {
            int len = read(fd[0], buf, sizeof(buf));
            buf[len] = '\0';
            printf("recv = %s\n", buf);
        }
     return 0;
}

有名管道**：任意两个进程间通信
API: int mkfifo(const char *pathname,mode_t mode)

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

int main()
{
    pid_t pid;
    if (mkfifo("/tmp/p1", 0644) < 0)
    {
        perror("mkfifo error!");
        exit(1);
    }
     pid = fork();

    if (pid == -1)
    {
        perror("fork error!");
        exit(1);
    }

    if (pid == 0)
    {
    int fd = open("/tmp/p1", O_WRONLY);
        if (fd == -1)
        {
            perror("open file error!");
            exit(1);
        }

        char buf[100] = {0};

        while (1)
        {
            scanf("%s", buf);
            write(fd, buf, strlen(buf));
        }
    }
    else if (pid > 0)
    {
    int fd = open("/tmp/p1", O_RDONLY);
        if (fd == -1)
        {
            perror("open file error!");
            exit(1);
        }

        char buf[100] = {0};
        while (1)
        {
            int len = read(fd, buf, sizeof(buf));
            buf[len] = '\0';
            printf("recv = %s\n", buf);
        }
    }

    return 0;
}

下面是任意两个进程间通信的代码
write.c

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

int main()
{
    int fd = open("/tmp/p1", O_WRONLY);
    if (fd == -1)
    {
        perror("open file error!");
        exit(1);
    }

    char buf[100] = {0};

    while (1)
    {
        scanf("%s", buf);
        write(fd, buf, strlen(buf));
    }

    return 0;
}

read.c

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

int main()
{
    if (mkfifo("/tmp/p1", 0644) < 0)
    {
        perror("mkfifo error!");
        exit(1);
    }

    int fd = open("/tmp/p1", O_RDONLY);
    if (fd == -1)
    {
        perror("open file error!");
        exit(1);
    }

    char buf[100] = {0};
    while (1)
    {
        int len = read(fd, buf, sizeof(buf));
        buf[len] = '\0';
        printf("recv = %s\n", buf);
    }

    return 0;
}

消息队列

传送有格式的消息流
多进程网状交叉通信时，消息队列是上上之选
能实现大规模数据通信
API（4个）
int msgget (key_t key,int msgflag) （创建消息队列）
int msgsnd (int msqid,const voidmsgp,size_t msgsz,int msgflg) //将消息写入到消息队列
ssize_t msgrcv (int msqid,voidmsgp,size_t msgsz,long msgtyp,int msgflg)//从消息队列读取消息
int msgctl(int msqid,int cmd,struct msqid_ds*buf) //释放消息队列

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

struct msgbuf
{
    /* data */
    long id;
    char buf[100];
};

int main()
{
    pid_t pid;

    key_t key;
    key = ftok("/tmp/1", 'a');

    //msgid消息队列描述符 == 文件描述符
    int msgid = msgget(key, IPC_CREAT | 0644);
    //int msgid = msgget(IPC_PRIVATE, IPC_CREAT | 0644);

    if (msgid < 0)
    {
        perror("msg get error!");
        exit(1);
    }

    pid = fork();

    if (pid < 0)
    {
        perror("fork error!");
        exit(1);
    }

    if (pid == 0)
    {
        //msgid
        struct msgbuf msg;
        msg.id = 1;
        strcpy(msg.buf, "hello world");
        msgsnd(msgid, &msg, sizeof(struct msgbuf), 0);

        msg.id = 2;
        strcpy(msg.buf, "hello world2");
        msgsnd(msgid, &msg, sizeof(struct msgbuf), 0);
        
        msg.id = 3;
        strcpy(msg.buf, "hello world3");
        msgsnd(msgid, &msg, sizeof(struct msgbuf), 0);
    }
    else if (pid > 0)
    {
        //msgid

        struct msgbuf msg;

        msgrcv(msgid, &msg, sizeof(struct msgbuf), 2, 0);

        printf("recv:%s\n", msg.buf);

        wait(NULL);

        msgctl(msgid,IPC_RMID,NULL);
    }

    return 0;
}

共享内存

特点：减少了进入内核空间的次数，效率高

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

int main()
{
    pid_t pid;

    key_t key;
    key = ftok("/tmp/kk", 'k');

    int shmid = shmget(key, 1024, IPC_CREAT | 0644);

    if (shmid < 0)
    {
        perror("shm get error!");
        exit(1);
    }

    pid = fork();

    if (pid < 0)
    {
        perror("fork error!");
        exit(1);
    }

    if (pid == 0)
    {
        //shmid
        void *addr = shmat(shmid, NULL, 0);
        char buf[100] = {0};
        while (1)
        {
            scanf("%s", buf);
            strcpy((char *)addr, buf);
            sleep(1);
        }
    }
    else if (pid > 0)
    {
        //shmid
        sleep(1);

        void *addr = shmat(shmid, NULL, 0);
        while (1)
        {
            if (strlen((char *)addr) > 0)
            {
                printf("recv = %s\n", (char *)addr);
            }
            else
            {
                printf("no data!");
            }
            sleep(1);
            
        }
    }

    return 0;
}

信号量

当多个进程/线程进行共享操作时，用于资源保护，以防止出现相互干扰的情况出现
互斥

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

int main()
{

    pid_t pid;

    key_t key = ftok("/tmp/5", 'p');

    int semid = semget(key, 1, IPC_CREAT | 0644);

    if(semid < 0)
    {
        perror("sem get error!");
        exit(1);
    }
    
    if(semctl(semid,0,SETVAL,1) < 0)
    {
        perror("semctl error!");
        exit(1);
    }

    if ((pid = fork()) < 0)
    {
        perror("frok error!");
        exit(1);
    }

    //b.txt

    if (pid == 0)
    {
        //"hello world\n"

        int fd = open("b.txt", O_WRONLY);
        if (fd == -1)
        {
            perror("open file error!");
            exit(1);
        }
        
        struct sembuf sem;
        sem.sem_num = 0;
        sem.sem_flg = SEM_UNDO;

        while (1)
        {
            //-1  p
            sem.sem_op = -1;
            semop(semid,&sem,1);
            write(fd, "hello", 5);
            write(fd, "world", 5);
            write(fd, "\n", 1);
            sem.sem_op = +1;
            semop(semid,&sem,1);
            //v
            //+1
            //sleep(1);
        }
    }
    else if (pid > 0)
    {
        //"hhhhh wwwww\n"

        int fd = open("b.txt", O_WRONLY);
        if (fd == -1)
        {
            perror("open file error!");
            exit(1);
        }

        struct sembuf sem;
        sem.sem_num = 0;
        sem.sem_flg = SEM_UNDO;

        while (1)
        {
            //-1
            sem.sem_op = -1;
            semop(semid,&sem,1);
            write(fd, "hhhhh", 5);
            write(fd, "wwwww", 5);
            write(fd, "\n", 1);
            sem.sem_op = +1;
            semop(semid,&sem,1);
            //+1
            //sleep(1);
        }
    }

    return 0;
}

未完待续

请你吃颗糖吧
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
嵌入式linux学习笔记之进程间通信
changqiang08的专栏
07-22 1396
（1）进程间通信目的 1、数据传输：一个进程需要将它的数据发送给另一个进程。 2、资源共享：多个进程之间共享同样的资源。 3、通知事件：一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事件。 4、进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有操作，并能够及时知道它的状态改变。 （2）Linux进程间通信（
Linux常用命令1
weixin_45639224的博客
09-12 278
Linux常用命令1
嵌入式Linux进程间的通信方式
ShawnWang1994的博客
11-30 1049
【1】分类 早期进程间通信方式： 无名管道 有名管道 信号通信 system V 消息队列 共享内存 信号灯集 BSD scoket（套接字）通信 【2】本质 任何一个进程在32位操作里面都会有4G的虚拟空间，包含1G内核空间和3G用户空间，进程间能够通信，就是在内核空间进行读写数据。 共享内存效率最高，它是直接获取到物理内存的地址，对物理内存直接操作。 前六种进程间通信方式只能实现在同一台主机...
Linux 中的权限
weixin_30701575的博客
09-19 142
ABCD A－0， 十进制 B－user(u, 用户) C－group(g, 组用户) D－others(o, 其他用户) +-----+---+--------------------------+ | rwx | 7 | Read, write and execute | | rw- | 6 | Read, write | | r-x | 5 | Read, an...
Linux 进程间通信
人生一世 草木一秋
08-12 2484
Linux进程通信继承了传统的UNIX进程间通信方式，包括无名管道、有名管道以及信号；还有System V进程间通信（IPC），包括System V消息队列、System V信号量以及System V共享内存；套接字。
Linux进程间通信【命名管道】
北 海的博客
06-07 1万+
命名管道通信属于IPC的其中一种方式，作为管道家族，命名管道的特点就是自带同步与互斥机制、数据单向流通，与匿名管道不同的是：命名管道有自己的名字，因此可以被没有血缘关系的进程看到，意味着命名管道可以实现毫不相干的两个独立进程间通信
Linux进程间通信详解（最全）
qq_40989769的博客
03-08 2382
进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享内存、Socket（套接字）等。其中 Socket和支持不同主机上的两个进程IPC。
Linux进程间通信(Linux IPC)
Peerless__的博客
06-04 6233
在Linux下由很多种进程间通信的方式，在下面主要介绍七种，分别是：匿名管道(PIPE)、命名管道(FIFO)、信号、共享内存映射、共享内存、消息队列、信号量、UNIX域套接字。
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
浅谈Linux进程间通信方式及优缺点
01-11
有名管道也是一种半双工的通信方式,但是它允许无亲缘关系进程间的通信。 2)信号量 信号量是一个计数器,可以用来控制多个线程对共享资源的访问.,它不是用于交换大批数据,而用于多线程之间的同步.它常作为一种锁机制...
linux-linux进程间通信方式汇总.zip
02-26
linux linux_linux进程间通信方式汇总
Linux进程间通信--使用信号
09-15
Linux进程间通信是一种让不同进程之间交换信息或协调工作的方式，而在Linux系统中，信号（Signal）是一种简单但重要的通信机制。本文将深入探讨如何利用信号进行进程间通信。 首先，信号是操作系统用来通知进程发生...
Linux进程间通信—信号量
热门推荐
123
11-11 1万+
进程间通信（interprocess communication，简称 IPC）指两个进程之间的通信。系统中的每一个进程都有各自的地址空间，并且相互独立、隔离，每个进程都处于自己的地址空间中。所以同一个进程的不同模块譬如不同的函数）之间进行通信都是很简单的，譬如使用全局变量等。但是，两个不同的进程之间要进行通信通常是比较难的，因为这两个进程处于不同的地址空间中。
DVR系统设计的大致思路和模块划分
lida2003的专栏
06-15 1005
设计和落地一个DVR（数字视频录像机）系统需要涵盖多个方面，从需求分析到硬件选择、软件开发和测试。这些步骤涵盖了DVR系统设计的主要环节，从初期的需求分析到最终的部署和运维，确保系统能够满足用户需求并稳定运行。OpenIPC是一个开源的操作系统，针对一些使用ARM和MIPS处理器的网络摄像机，以替代供应商预装的那种封闭的、不透明的、不安全的、不再更新的、不支持的固件。DVR系统设计其实并不是新鲜的东西，反之，这是一个标准化程度非常高的系统化产品类别。缺点：成本较高，光纤的操作和维护较为复杂。
【GD32定时器】高级定时器生成PWM波+定时器外设配置DMA使用
weixin_44006573的博客
06-18 681
DMA 控制器提供了一种硬件的方式在外设和存储器之间或者存储器和存储器之间传输数据，而无需 CPU 的介入，从而使 CPU 可以专注在处理其他系统功能上。
【ARMv8/ARMv9 硬件加速系列 2.2 -- ARM NEON 的加减乘除(左移右移)运算】
最新发布
CodingCos的博客
06-18 793
最后，这个示例是基于假设的代码片段，具体实现时根据目标环境和需求可能需要做相应的调整。加载数据，对它们进行加、减和乘,左移和右移操作。最后，我们会将结果存储到内存地址。ARMv8的SIMD指令集允许对向量寄存器中的多个数据进行并行操作。指令使用了后置更新地址的写法，每次存储后都会更新。下面代码是使用ARMv8汇编语言对向量寄存器。执行加、减、乘以及左移和右移操作的示例。寄存器的值，为下一次存储准备。处, 方便观察结果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值