Linux系统编程——进程间通信

已于 2023-04-03 21:36:27 修改
阅读量488 收藏 2
点赞数 1
文章标签： linux 运维 服务器
于 2022-11-07 22:41:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67407774/article/details/127721933
版权

目录

一、无名管道

相关概念

相关函数介

相关说明

实战

 二、有名管道

有名管道和无名管道的区别

有名管道和无名管道的相同点

有名管道的相关函数

实战

三、消息队列

消息队列的介绍

消息队列的特点      

相关函数

实战

四、共享内存

共享内存优缺点

共享内存的特点

相关函数介绍

实战

五、信号

信号概述

信号入门版——不带信息，单纯地接受和发送信号

信号高级版——带消息

实战

六、信号量

信号量概述

信号量简述

相关函数介绍

七、ipcs指令与ipcrm指令

一、无名管道

  • 相关概念

  1. 无名管道和有名管道是Linux系统内核的特殊文件，用于进程之间的通信。
  2. 无名管道是在父进程与子进程之间通信使用的，并且只能用于父子进程间的通信。
  3. 无名管道相当于一个队列结构。其中信息读出后即删除，再次读取时即为下一个信息。 

  • 相关函数介

    • pipe函数：int pipe(fd[2])，fd[1]为写入端（入队），fd[0]为读出端（出队）        

      1. 该函数的作用为创造无名管道文件。由于是特殊文件所以不可由open函数创建。
      2. 无名管道是Linux系统内核的特殊文件，所以fd[0]和fd[1]都是文件描述符。
      3. 成功返回0，失败返回-1。

  • 相关说明

  1. 管道是创建在内存中的，当进程结束时，空间就会释放。
  2. 无名管道和有名管道都是半双工通信，若想实现同时的双向通信需要建立两个管道。
  3. 无名管道是Linux特殊文件，不能再Windows共享文件夹中创建。
  4. 无名管道只能在父子进程间通信。

  • 实战

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

int main()
{
        pid_t pid;
        int fd[2];
        char buf[1024] = {0};

        if(pipe(fd) < 0){
                printf("creat pipe failed!\n");
        }

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

        if(pid == 0){
                printf("this is child!\n");
                close(fd[1]);
                int nread = read(fd[0],buf,1024);
                printf("read:%d,content:%s\n",nread,buf);
                exit(0);
        }else{
                printf("this is fsther!\n");
                close(fd[0]);
                write(fd[1],"father's data!",20);
                wait(NULL);
        }

        return 0;
}

程序运行后结果为 

 二、有名管道

  • 有名管道和无名管道的区别

  1. 无名管道只能用于父子进程之间通信，而有名管道可用于非父子进程之间的通信。
  2. 无名管道通过pipe函数创建出来的不需要通过open函数打开，而有名函数创建出来的需要通过open函数打开。并且有名管道在创建管道时需要设置权限，而无名管道不用。
  3. 无名管道会随着进程的结束而消失，而有名管道不会，但是有名管道中的数据会随着数据的读出而消除。
  4. 无名管道的文件无法在系统中看到，而有名管道FIFO文件可以在系统中看到。所以有名管道比无名管道更持久跟稳定。

  • 有名管道和无名管道的相同点

  1. 有名管道和无名管道都属于系统的特殊文件。
  2. 有名管道和无名管道都属于半双工通信。
  3. 无名管道和有名管道都是通过write函数和read函数进行读写的。

  • 有名管道的相关函数

    • int mkfifo(const char *pathname, mode_t mode);
    1. 该函数作用是创建有名管道的FIFO文件
    2. *pathname为路径名，mode为权限。
    3. 成功返回0，失败返回-1。

  • 实战

当读程序与写程序都进行了管道创建，则要注意去除EEXIST错误信息。

注意：当使用open函数打开时，尽量使用只读或只写的权限打开

读与创建程序

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

int main()
{
        int fd;
        char buf[128] = {0};

        if((mkfifo("./file",0777) < 0) & (errno != EEXIST)){
                printf("create fifo failed!\n");
        }

        fd = open("./file",O_RDONLY);

        while(1){
                int nread = read(fd,buf,128);

                printf("read:%d,context:%s\n",nread,buf);
        }
        close(fd);

        return 0;
}

 写与创建程序

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

int main()
{
        int fd;
        int cnt = 0;
        char buf[128] = "zhen shuai!";

        if((mkfifo("./file",0777) < 0) & (errno != EEXIST)){
                printf("create fifo failed!\n");
        }

        fd = open("./file",O_WRONLY);

        while(1){
                write(fd,buf,strlen(buf));
                sleep(1);
                if(cnt == 5){
                        break;
                }
                cnt++;
        }

        close(fd);

        return 0;
}

三、消息队列

  • 消息队列的介绍

    • 消息队列通过名字字面意思理解就是队列排队结构，消息队列与FIFO很相似，都是一个队列结构，都可以有多个进程往队列里面写信息，多个进程从队列中读取信息。但FIFO需要读、写的两端事先都打开，才能够开始信息传递工作。而消息队列可以事先往队列中写信息，需要时再打开读取信息。          

  • 消息队列的特点      

    1. 消息队列属于顺序队列形式的结构，向队列里写的每一条消息，会追加到队列后面，读取一个就从队列里消除一个。
    2. 写函数不会阻塞，除非队列里存放的消息数量已经满了，才会导致阻塞。
    3. 读函数，从队列里读取不到数据时，会阻塞。

    4. 消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。

    5. 消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。

  • 相关函数

    函数原型函数作用及返回值函数参数

    int msgget(key_t key, int flag);

    		创建或打开消息队列：成功返回队列ID，失败返回-1key：消息对列的表示（一般通过ftok函数获得）
    flag：指名队列的访问权限和创建标志，创建标志为IPC_CREAT、IPC_EXC

    int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

    		添加消息：成功返回0，失败返回-1

    msgid:消息队列的id，通常为msgget的返回值

    msgp：是消息结构体。long mtype：接受进程可以用此值进行消息选择
    char mtext：是一个数组，他的最大允许长度由msgsz决定
    msgsz：用来决定mtext中最大长度。
    msgflg：0是阻塞、IPC_NOWAIT队列满时函数不等待直接返回、IPC_NOERROR当发送字节大于size字节时，阶段部分将被丢弃，且不通知发送进程。

    int msgrcv(int msqid, const void *msgp, size_t msgsz, long msgtyp,int msgflg);

    		读取消息：成功返回消息数据的长度，失败返回-1msgid：与msgsnd函数一样。
    msgp：与msgsnd函数一样。
    msgsz：与msgsnd函数一样。

    msgtyp>0:接受第一个类型等于msgtyp的消息

    msgtyp==0:接受队列中的第一个消息

    msgtyp<0:接受类型小于或等于msgtyp绝对值的第一个最低类型消息

    msgflg：与msgsnd函数一样。
    int msgctl(int msqid, int cmd, struct msqid_ds *buf);控制消息队列，常用来删除消息队列：成功返回0，失败返回-1msqid：消息队列标识符
    cmd：通常为IPC_RMID表示删除消息队列
    buf：通常为NULL

  • 实战

        发送信息

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

struct msgbuf {
       long mtype;       /* message type, must be > 0 */
       char mtext[128];    /* message data */
};

int main()
{
        key_t key = ftok(".",1);
        int msqid;
        struct msgbuf msgp = {888,"xiaoyang zhen shuai!"};

        msqid = msgget(key,IPC_CREAT|0777);

        int nrcv = msgsnd(msqid,&msgp,strlen(msgp.mtext),0);

        msgctl(msqid,IPC_RMID,0);

        return 0;
}

        接受信息

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

struct msgbuf {
       long mtype;       /* message type, must be > 0 */
       char mtext[128];    /* message data */
};

int main()
{
        key_t key = ftok(".",1);;
        int msqid;
        struct msgbuf msgp;

        msqid = msgget(key,IPC_CREAT|0777);

        if(msqid < 0){
                printf("creat failed!\n");
                perror("why");
        }

        int nrcv = msgrcv(msqid,&msgp,128,888,0);

        printf("rcv = %d,context = %s\n",nrcv,msgp.mtext);

        msgctl(msqid,IPC_RMID,0);

        return 0;
}

四、共享内存

共享内存（Shared Memory），指两个或多个进程共享一个给定的存储区。

  • 共享内存优缺点

    • 共享内存相比其他几种方式有着更方便的数据控制能力，数据在读写过程中会更透明。当成功导入一块共享内存后，它只是相当于一个字符串指针来指向一块内存，在当前进程下用户可以随意的访问。缺点是，数据写入进程或数据读出进程中，需要附加的数据结构控制。

  • 共享内存的特点

    1. 由于是直接对内存进行读取，所以共享内存是最快的一种IPC
    2. 因为可以多个进程同时操作，所以需要进行同步
    3. 共享内存通常和信号量共同使用，信号量用来同步共享内存的访问

  • 相关函数介绍

函数名称函数作用及返回值函数参数
int shmget(key_t key,size_t size,int flag)用来创建共享内存。成功返回共享内存ID，失败返回-1。key：用来变换成一个标识符
size：为要请求的内存长度（内核是以页为单位分配内存，当size参数的值不是系统内存页长的整数倍时，系统会分配给进程最小的可以满足size长的页数，但是最后一页的剩余部分内存是不可用的。）
flag：IPC_CREAT（注意要增加权限）、IPC_EXCL
void *shmat(int shm_id, const void *addr, int flag);用来建立进程与共享内存之间的连接。成功返回指向共享内存的指针，失败返回-1。shm_id：指定要引入的共享内存
addr：和flag共同决定引入的地址值addr为0，表明让内核来决定第1个可以引入的位置。
flag：和addr共同决定引入的地址值addr非零，并且flag中指定SHM_RND，则此段引入到addr所指向的位置（此操作不推荐使用，因为不会只对一种硬件上运行应用程序，为了程序的通用性推荐使用第1种方法）。为0则为读写的方式，为SHM_RDONLY为只读。
int shmdt(void *addr);用来断开进程与共享内存之间的连接。成功返回0，失败返回-1。参数addr是调用shmat函数的返回值
int shmctl(int shm_id, int cmd, struct shmid_ds *buf);用来根据cmd指令对共享内存进行操作，刚用来删除共享内存。成功返回0，失败返回-1。shm_id：指定要控制的共享内存
cmd：常用的是IPC_RMID（从系统中删除该共享内存）。
buf：通常再删除时为0.

  • 实战

    • 读数据
#include <stdio.h>
#include <sys/types.h>
#include <sys/shm.h>

int main()
{
        key_t key;
        int shmid;
        char *shmaddr;

        key = ftok(".",1);

//      shmid = shmget(key,1024 * 4,IPC_CREAT|0666);
        shmid = shmget(key,1024 * 4,0);
        if(shmaddr < 0){
                printf("shmget failed!\n");
        }

        shmaddr = shmat(shmid,NULL,0);

        printf("data = %s\n",shmaddr);

        shmdt(shmaddr);
        shmctl(shmid,IPC_RMID,0);

        return 0;
}

写数据

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

int main()
{
        int shmid;
        key_t key;
        char *shmaddr;
        char buf[128] = {0};

        key = ftok(".",1);

        shmid = shmget(key,1024 * 4,IPC_CREAT|0666);
        if(shmid > 0){
                printf("shmget success!\n");
        }

        shmaddr = shmat(shmid,NULL,0);

        strcpy(shmaddr,"xiaoyang");
        printf("write success!\n");

        shmdt(shmaddr);

        return 0;
}

五、信号

  • 信号概述

    1. 对于 Linux来说，实际信号是软中断，许多重要的程序都需要处理信号。信号，为 Linux 提供了一种处理异步事件的方法。比如，终端用户输入了 ctrl+c 来中断程序，会通过信号机制停止一个程序。

    2. 信号的名字和编号：每个信号都有一个名字和编号，这些名字都以“SIG”开头，例如“SIGIO ”、“SIGCHLD”等等。信号定义在signal.h头文件中，信号名都定义为正整数。具体的信号名称可以使用kill -l来查看信号的名字以及序号，信号是从1开始编号的，不存在0号信号。kill对于信号0又特殊的应用

    3. 信号的处理：信号的处理有三种方法，分别是：忽略、捕捉和默认动作

      1. 忽略信号：为忽略信号不执行原本的操作，但是sigkill和sigstop无法忽略。可以通过SIG_IGN这个宏进行忽略

      2. 捕捉信号：通过用户自定义函数来告诉内核，当信号到来时调用该函数，做相应的操作操作。

      3. 默认动作：系统默认的动作，每个信号都有其对应的默认动作。

    4. 当执行一个程序时，所有信号的状态都是系统默认或者忽略状态的。除非是调用exec进程忽略了某些信号。exec函数将原先设置为要捕捉的信号都更改为默认动作，其他信号的状态则不会改变 。
    5. 当一个进程调动了 fork 函数，那么子进程会继承父进程的信号处理方式。

  • 信号入门版——不带信息，单纯地接受和发送信号

    1. kill指令发送信号给进程，如发送序号为9的SIGKILL信号，kill -9 pid
    2. 相关函数介绍
      函数名称函数作用及返回值函数参数
      int kill(pid_t pid, int sig);向对应的pid进程发送信号。成功返回0，失败返回-1.pid：对应进程的pid
      sig：需要发送的信号的序号
      sighandler_t signal(int signum, sighandler_t handler);信号注册函数。成功返回一个特定处理函数的指针，失败返回SIG_ERRsignum：信号的序号
      handle：函数指针，指向中断函数

    3. 实战

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

//typedef void (*sighandler_t)(int);
//sighandler_t signal(int signum, sighandler_t handler);

void sighandle(int signum)
{
        switch(signum){
                case 2:
                        printf("SIGINT\n");
                        break;
                case 1:
                        printf("SIGUP\n");
                        break;
                case 10:
                        printf("SIGUSE1\n");
                        break;

        }

}

int main()
{
        signal(SIGINT,SIG_IGN);
        signal(SIGUSR1,sighandle);
        signal(SIGHUP,sighandle);

        while(1);
        return 0;
}

        

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

//int kill(pid_t pid, int sig);

int main(int argc,char **argv)
{
        int pid;
        int signum;
        char cmd[128] = {0};

        if(argc != 3){
                printf("input error!\n");
        }

        pid = atoi(argv[2]);
        signum = atoi(argv[1]);

        sprintf(cmd,"kill -%d -%d",signum,pid);

//      if((kill(pid,signum)) < 0){
//              perror("kill");
//      }

        system(cmd);

        return 0;
}

  • 信号高级版——带消息

    1. 相关函数介绍
    2. 在使用sigqueue函数时需要确认的几点操作
      1. 使用 sigaction 函数安装信号处理程序时，制定了 SA_SIGINFO 的标志。
      2. sigaction 结构体中的 sa_sigaction 成员提供了信号捕捉函数。如果实现的时 sa_handler 成员，那么将无法获取额外携带的数据
函数名称函数作用以及返回值函数参数
int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);接受信号及其携带的消息。成功返回0，失败返回-1signum：传输信号的序号
act：结构体 (*sa_handler)(int)：与signal函数的handle相同
(*sa_sigaction)(int, siginfo_t *, void *)：为函数指针。int为信号的序号；void*是接收到信号所携带的额外数据；而struct siginfo这个结构体主要适用于记录接收信号的一些相关信息
sa_mask：sa_mask 成员用来指定在信号处理函数执行期间需要被屏蔽的信号
sa_flags：通常使用SA_SIGINFO，使用 sa_sigaction 成员而不是 sa_handler 作为信号处理函数。
oldac：为记录信号之前的内容。
int sigqueue(pid_t pid, int sig, const union sigval value);只能把信号发送给单个进程，可以使用 value 参数向信号处理程序传递整数值或者指针值。pid：接收信号的进程id
sig：发送信号的序号
value：联合体，指定信息传递的参数。

  • 实战

发送

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

//       int sigqueue(pid_t pid, int sig, const union sigval value);

int main(int argc,char **argv)
{
        if(argc != 3){
                printf("put data number error!\n");
                exit(1);
        }

        int pid;
        int signum;

        pid = atoi(argv[2]);
        signum = atoi(argv[1]);

        union sigval value;
        value.sival_int = 100;

        sigqueue(pid,signum,value);

        printf("done!\n");

        return 0;
}

接受

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

//       int sigaction(int signum, const struct sigaction *act,
//                     struct sigaction *oldact);

void handle(int signum, siginfo_t *info, void *context)
{
        printf("get signal = %d\n",signum);

        if(context != NULL){
                printf("get Signal number = %d\n",info->si_signo);
                printf("get data = %d\n",info->si_int);
                printf("get value data = %d\n",info->si_value.sival_int);
        }
}

int main()
{
        struct sigaction act;

        act.sa_sigaction = handle;
        act.sa_flags = SA_SIGINFO;

        sigaction(SIGUSR1,&act,0);

        printf("pid = %d\n",getpid());

        while(1);
        return 0;
}

六、信号量

  • 信号量概述

    1. 信号量（semaphore）是操作系统中用来解决并发中的互斥和同步问题的一种方法。
    2. 最简单的信号量是只能取 0 和 1 的变量，这也是信号量最常见的一种形式，叫做二值信号量（Binary Semaphore）。而可以取多个正整数的信号量被称为通用信号量。Linux下的函数都是对通用信号量进行操作。

  • 信号量简述

    • 信号量就是所谓的钥匙，假设只有一把钥匙，当有人拿走了这把钥匙，那么另一个人就无法打开这扇门需要等待拿走这把钥匙的人将钥匙重新放回来，才可以打开这扇门。信号量就是防止过多的进程访问同一个公共资源。

  • 相关函数介绍

    1. semget：创建或获取一个信号量组。
      1. int semget(key_t key, int nsems, int semflg);
      2. 创建或获取一个信号量组：若成功返回信号量集ID，失败返回-1
      3. 当semget创建新的信号量集合时，必须指定集合中信号量的个数（即nsems），通常为1； 如果是引用一个现有的集合，则将nsems指定为 0 。
    2. semop：对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1。
      1. int semop(int semid, struct sembuf *sops, unsigned nsops);
      2. 函数参数参数意义
        semid信号量集的标识符，一般由semget返回的。
        *sops     sembuf结构体的数组指针short sem_num：信号量组中对应的序号，0～sem_nums-1
        short sem_op：信号量值在一次操作中的改变量（一般为+1、-1）
        short sem_flg：IPC_NOWAIT, SEM_UNDO（一般选择UNDO阻塞）
        nsops为sops中的元素个数
    3. semctl：控制信号量的相关信息，与消息队列中的msgctl相似
      1. int semctl(int semid, int semnum, int cmd, union semun arg);
      2. cmd：
        1. IPC_STAT：获得该信号量的semid_ds结构，并存放在第四个参数arg结构变量的buf域指向的semid_ds结构
        2. IPC_SETVAL：将信号量值设置为arg的val值
        3. IPC_GETVAL：返回信号量当前值
        4. IPC_RMID：从系统中删除信号量
      3. 函数参数参数意义
        semid信号量集的标识符
        semnum信号量组中对应的序号
        cmd

        SETVAL：用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。对于刚创建的新信号量必须要进行设置。对于使用同一个key的只需要设置一次即可。

        IPC_RMID：删除一个信号量集合。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。
        union semun该函数有三个或四个参数，而几个参数是由cmd决定的，该参数就是第四个参数。联合体。如果使用该参数，则其类型为semun。

实战

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

union semun {
       int              val;    /* Value for SETVAL */
       struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
       unsigned short  *array;  /* Array for GETALL, SETALL */
       struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                   (Linux-specific) */
};

void pGetKey(int semid)
{
        struct sembuf set;

        set.sem_num = 0;
        set.sem_op = -1;
        set.sem_flg = SEM_UNDO;

        semop(semid,&set,1);

        printf("get key!\n");
}

void vPutKey(int semid)
{
        struct sembuf set;

        set.sem_num = 0;
        set.sem_op = +1;
        set.sem_flg = SEM_UNDO;

        semop(semid,&set,1);

        printf("put back key!\n");
}

int main()
{
        int semid;
        int key;
        int pid;

        key = ftok(".",2);

        semid = semget(key,1,IPC_CREAT|0666);

        union semun initsem;

        initsem.val = 0;
        semctl(semid,0,SETVAL,initsem);

        pid = fork();

        if(pid > 0){
                pGetKey(semid);
                printf("this is father!\n");
                vPutKey(semid);
        }
        if(pid == 0){
                printf("this is child!\n");
                vPutKey(semid);
        }

        semctl(semid,0,IPC_RMID,initsem);

        return 0;
}

七、ipcs指令与ipcrm指令

忘崽奶糖
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
进程间通信：消息队列示例代码
06-02
Linux系统编程——进程间通信：消息队列，相关教程链接如下： http://blog.csdn.net/tennysonsky/article/details/46331643
Linux Socket编程入门——浅显易懂
01-06
文章目录1. 概述2. Socket3. 网络字节序4. sockaddr 数据结构5. 网络套接字API函数 5.1 socket（） 5.2 bind（） 5.3 listen（） 5.4 accept（） 5.5 connect（）6. 一个简单的C/S模型代码实例7.总结 1. 概述   网络通信，首先那些七层模型等概念，小的不才，之前有写过几篇关于网络的文章，如果有时间，可以去看看，浅显易懂。可能写的不好，但这里只是个人的一些见解吧。 2. Socket   Socket本身有“插座”的意思，在Unix/Linux环境下，用于表示进程间网络通信的特殊文件类型（Linux下一切皆文件
Linux进程间通信——使用流套接字
01-20
前面说到的进程间的通信，所通信的进程都是在同一台计算机上的，而使用socket进行通信的进程可以是同一台计算机的进程，也是可以是通过网络连接起来的不同计算机上的进程。通常我们使用socket进行网络编程，这里将会简单地讲述如何使用socket进行简单的网络编程。 一、什么是socket socket，即套接字是一种通信机制，凭借这种机制，客户/服务器（即要进行通信的进程）系统的开发工作既可以在本地单机上进行，也可以跨网络进行。也就是说它可以让不在同一台计算机但通过网络连接计算机上的进程进行通信。也因为这样，套接字明确地将客户端和服务器区分开来。 二、套接字的属性 套接字的特性由3个属性确定，它
高级进程间通信问题——快速排序问题1
08-03
(1) 首先产生包含 1,000,000 个随机数（数据类型可选整型或者浮点型）的数据文件 (2) 每次数据分割后产生两个新的进程（或线程）处理分割后的数据，每
浅谈进程通信
qq_51143945的博客
08-22 752
对进程通信的理解
Linux学习——进程间通信(初识)
qq_22842309的博客
09-09 219
Linux学习——进程间通信 进程间通信（IPC，Interprocess communication）： 是一组编程接口，让程序员能够协调不同的进程，使之能在一个操作系统里同时运行，并相互传递、交换信息。 IPC方法：无名管道（pipe）、有名管道（fifo）、消息队列（msg）、共享内存（shm）、信号（sig）、信号量（sem） 1.无名管道（pipe） 个人认知：半双工通信，仅用在父子进程当中进行通信，当进程结束管道随之消失。 原型： #include <unistd.h> int
实验4 Linux父子进程同步及进程通信
江南、寻你的博客
05-11 3313
【实验目的】 （1）熟悉在c语言源程序中使用linux所提供的系统调用界面的方法。 （2）理解同步的概念。 （3）使用系统调用wait()和exit()，实现父子进程同步。 （4）使用pipe()系统调用创建管道，实现父子进程间的信息通信。 【实验环境】VMware Workstation、RedHat 【实验步骤】 1.1 使用vi编写程序，通过wait()和exit()实现父子进程同步，其同步方式为父进程等待子进程的同步，即：子进程先循环输出5次，然后父进程再循环输出5次。 1.2 使用
进程间通信（系统编程）
嵌入式C
03-27 438
进程间通信：用户空间不可以通信，只在内核中通信 线程间通信：用户空间可以通信，通过全局变量进行通信 要想实现父进程先运行子进程后运行，可以加一个全局变量或者局部变量阻塞子进程的运行。 通信方式：管道、信号、IPC(共享内存，消息队列，信号灯) 占用内存的只有目录文件，软链接，套接字文件？ 有名管道，字符设备，块设备，套接字他们不占用磁盘空间，只有文件节点 atoi(字符串)：将字符串转换为数字 sprintf(buf,"%d",num);将数字转化为字符串 无名管道：pipe(pipefd..
进程间通信编程
weixin_43296982的博客
03-05 1197
1.进程间通信方式概述 进程间通信是在不同进程之间传播或者交换信息。 进程间通信方法有:管道(无名和有名管道)，消息队列，信号量，共享内存，信号，套接字等 进程间通信的目的: 1、数据传输，2、共享数据，3、通知事件，4、资源共享，5、进程控制 2.管道通信 管道有无名管道和有名管道，无名管道是适用于父子进程或者兄弟进程之间，进程之间存在联系的，可以用管道。 有名管道，不仅父子，兄弟进程可以使用，没有关系的两个进程也可以使用，有名管道克服了管道没有名字的限制。所以才可以字无关系的进程之间建立通信。传递的数据
Linux学习笔记之进程间通信篇(3)_消息传递
979
06-07 1252
正式进入进程间通信了，本节主要介绍下消息传递的相关概念和用法，分为管道与消息队列。
Linux之进程间通信②——管道（pipe、fifo）
夹心狗勾的博客
03-10 827
Linux之进程间通信——管道
深入理解进程间通信
century_sunshine的博客
04-10 4504
深入理解进程间通信何为进程间通讯呢？顾名思义，它指的是不同进程之间传播和交换信息。主体是进程，且是大于等于2个进程；工作是通讯，数据交换。在讲进程通讯之前，先带大家了解一下都有哪些进程间通讯的方式？并对比总结一下它们各自的特点和使用范围。1.有名管道： 有管道文件 任意进程之间2.无名管道： 没有管道文件 父子进程之间3.信号量： 同步控制4.消息队列： 定向发送数据5.共享内存： 最快的 IPC...
Linux下进程间通信方式——共享内存
最新发布
m0_74282605的博客
09-13 147
可能你会认为，可以改变一下written的使用方式，例如，只有当written为0时进程才可以向共享内存写入数据，而当一个进程只有在written不为0时才能对其进行读取，同时把written进行加1操作，读取完后进行减1操作。若共享内存的written为0，表示没有其他进程对共享内存进行读取，则提示用户输入文本，并再次设置共享内存中的written为1，表示写完成，其他进程可对共享内存进行读操作。IPC_SET：如果进程有足够的权限，就把共享内存的当前关联值设置为shmid_ds结构中给出的值。
【Linux】进程间通信
qq_53893431的博客
11-06 760
进程间通信
进程间的七种通信方式之-----（五）共享内存(share memory)
weixin_42538789的博客
04-25 1042
进程间的7种通信方式 之（三）共享内存 共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存，而不需要任何数据的拷贝 为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间 进程就可以直接读写这一内存区而不需要进行数据的拷贝，从而大大提高的效率。 示例代码 #include <stdio.h> #include <string.h> #include <stdlib.h> #include <unistd.h&g
Linux 进程间通信
冰果滴的博客
11-12 1249
因为进程是具有独立性的，所以进程间想交互数据，成本会非常高，因此需要多进程进行协同处理一件事情，就有了进程间通信。要注意，虽然进程独立了，但不是彻底独立了，有时候，需要双方能够进行一定程度的信息交互。
进程间通信之Linux管道编程
程序人生
11-10 3234
管道简述 管道（pipe）是Unix/Linux中最常见的进程间通信方式之一，它在两个进程之间实现一个数据流通的通道，数据以一种数据流的方式在进程间流动。在系统中，管道相当于文件系统上的一个文件，用于缓存所要传输的数据。在某些特性上又不同于文件，例如当数据读出后，管道中就没有数据了，但文件没有这个特性。管道有两个特点： ·部分系统下的管道是半双工的，数据在同一时间只能向一个方向流动。从实现的角...
Windows系统编程之进程间通信
donixli1314的专栏
01-16 652
标 题: Windows系统编程之进程间通信 作 者: 北极星2003 时 间: 2006-05-25,14:18 链 接: http://bbs.pediy.com/showthread.php?t=26252 Windows系统编程之进程间通信作者：北极星2003来源：看雪论坛（www.pediy.com）Windows 的IPC（进
Linux编程---进程通信
Coding Bad
06-17 972
Linux的通信方式主要有分类有下面几种: -匿名管道和FIFO有名管道 -消息队列,信号量和共享存储 -套接字 .对于套接字的进程通信,我就留在套接字的文章中再写了.   一.管道 管道是最古老的进程通信机制了.提供进程间的单向通信. 1.创建管道 int pipe(int fdes[2]); 实际上管道通过参数返回读和写的两个文件描述符.相当于是打开了两个文件吧.但是这个文
linux系统-进程间通信
07-27
进程间通信是指在Linux系统中，不同的进程之间通过操作系统提供的公共资源进行数据传输、资源共享、通知事件和进程控制的过程。\[1\]\[2\]常见的进程间通信方式包括共享内存、管道、消息队列和信号量等。\[2\]在实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值