Linux系统编程（三）进程间通信

最新推荐文章于 2024-07-06 09:49:08 发布
最新推荐文章于 2024-07-06 09:49:08 发布
阅读量159 收藏
点赞数
文章标签： linux c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42747843/article/details/129915577
版权

目录

进程间通信（IPC）

管道

无名管道

特点

1、只能在父子进程，兄弟进程等亲缘进程间进行数据交互
2、无名管道只是一种临时存在于内存中的临时文件，在文件系统中没有其相关的特殊文件，进程双方均具有读写端，可以调用read,write文件的API来对该临时文件进行操作
3、半双工工作方式：同一时刻数据只能在一个方向流动
图解过程：
在这里插入图片描述
如图：fd[0]为读端，fd[1]为写端，在某一时刻，父进程把读端关闭，子进程把写端关闭,父进程把数据写入管道，子进程把数据从管道里读出

API

创建无名管道

int pipe(int pipefd[2]);

第一个API可以实现父子进程之间简单的数据交互
编程实现：

#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
//int pipe(intfd[2])
int main()
{
    int fd[2];//通信双方分别通过fd[0],fd[1]来对管道数据进行操作，fd[0]为读操作，fd[1]为写操作
    pid_t pid;
    char buff[20];
    int status;
    if(pipe(fd) < 0){
        printf("create pipe failed\n");
        exit(-1);
    }
    else{
        printf("create pipe success\n");
    }
    pid = fork();
    if(pid < 0){
        printf("fork failed\n");
    }
    else if(pid > 0){
        sleep(3);
        close(fd[0]);
        write(fd[1],"helloworld",strlen("helloworld"));
        wait(&status);
    }
    else if(pid == 0){
        close(fd[1]);
        read(fd[0],buff,sizeof(buff));
        printf("read from father:%s\n",buff);
        exit(0);
    }


    return 0;
}

输出结果：
在这里插入图片描述

有名管道（FIFO）

特点

与无名管道相反，有名管道通过在文件系统中生成特殊文件来使两个无亲缘关系进程进行数据交互，与无名管道相同，同样可以调用文件API来进行操作

API

int mkfifo(const char *pathname, mode_t mode);

*pathname:创建管道文件的所在路径
mode:文件权限
编程实现

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

//int mkfifo(const char *pathname, mode_t mode);
int main()
{
    int ret = mkfifo("./file",0600);//调用函数后需要指明生成文件路径以及操作权限为可读可写
    if(ret == 0){
        printf("mkfifo success\n");//成功会在指定位置生成管道文件
    }
    else if(ret == -1){
        printf("mkfifo failed\n");
    }
    return 0;
}

执行后在文件系统中生成一个特殊的管道文件（图中黄色file）
在这里插入图片描述
两个无关系进程间信息交互`

//读进程
#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include <unistd.h>



int main()
{
    char buf[30] = {0};
    int fd = open("./file",O_RDONLY);

    printf("open fifo success\n");

    int n_read = read(fd,buf,30);

    printf("read %d bytes from fifo,content:%s\n",n_read,buf);
	close(fd);

    return 0;
}

//写进程
#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include <unistd.h>
#include<string.h>
int main()
{
    char *buf = "message from fifo";
    int fd = open("./file",O_WRONLY);

    printf("open fifo success\n");

    int n_write = write(fd,buf,strlen(buf));

    printf("write success\n");
	close(fd);




    return 0;
}

结果如下
在这里插入图片描述

在这里插入图片描述PS：只有读进程运行时，在调用只读open函数后，程序会进入堵塞状态直到有另外一个程序调用只写open来对管道文件进行打开时才会继续执行下去

消息队列

原理以及过程

消息队列特点：
1以链表形式存放在linux内核中，每个消息队列以队列ID号来进行区分
2消息队列是面向记录的，其中的消息具有特定格式以及优先级
3消息队列独立于发送以及接收进程，当进程终止时消息队列以及其内容不会被删除
4消息队列可实现信息的随机查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取
进程使用消息队列进行通信条件：
双方使用同一个消息队列
通信过程
发送信息进程：创建/获取消息队列，把消息写入到消息队列中
接收信息进程：创建/获取消息队列，根据键值找到对应消息队列，并从消息队列中读出消息
对应API

#include<sys/msg.h>//需要包含头文件

创建队列

int msgget(key_t key, int msgflg);
key为索引值，通过索引值在内核中寻找队列
msgflg表示打开队列的方式：如果内核中没有对应键值的消息队列并且msgflg中包含了IPC_CREAT标志位或者key参数为IPC—_PRIVATE时，msgget函数将创建一个新的消息队列，在创建新的消息队列后，需要在msgflg处说明消息队列的权限
返回值：成功返回消息队列ID号，失败返回-1

写入消息到队列中

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
msqid为写入进程在调用msgget函数成功后返回的队列ID
msgp指向一个msgbuf结构体
struct msgbuf{
	long mtype;//消息类型，非负
	char mtext[1];//消息内容
}
msgsz表示写入的大小，msgflg表示写入的方式

从队列中读出消息

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);
msqid为读取进程在调用msgget函数成功后返回的队列ID
msgp指针为读取进程接受信息的位置
与msgsnd不同的是nsgrcv多了一个msgtyp，用来在消息队列中根据类型寻找消息内容

键值设置

key_t ftok(const char *pathname, int proj_id);
第一个参数指定文件目录，.表示当前目录，第二个参数可根据自己需求来指定

控制消息队列

int msgctl(int msqid, int cmd, struct msqid_ds *buf);
第一个参数为队列ID，第二个参数为需要执行的命令
第三个参数为记录队列信息的结构体
struct msqid_ds {
               struct ipc_perm msg_perm;     /* Ownership and permissions */
               time_t          msg_stime;    /* Time of last msgsnd(2) */
               time_t          msg_rtime;    /* Time of last msgrcv(2) */
               time_t          msg_ctime;    /* Time of last change */
               unsigned long   __msg_cbytes; /* Current number of bytes in
                                                queue (nonstandard) */
               msgqnum_t       msg_qnum;     /* Current number of messages
                                                in queue */
               msglen_t        msg_qbytes;   /* Maximum number of bytes
                                                allowed in queue */
               pid_t           msg_lspid;    /* PID of last msgsnd(2) */
               pid_t           msg_lrpid;    /* PID of last msgrcv(2) */
           };
一般设置为空，

两进程通过消息队列进行消息收发代码

msgSend
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
//int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
struct msgBuf{
    long mtype;
    char mtext[128];
};
int main()
{
    key_t key = ftok(".",1);
    if (key != -1)
    {
        printf("key:%x\n",key);
    }
    int msgid = msgget(key,IPC_CREAT|0777);
    struct msgBuf sendBuf = {778,"this is message from queue"};
    if (msgid == -1)
    {
        printf("get queue failed\n");
    }
   else
    {
        printf("get queue success\n");
        printf("queue id:%d\n",msgid);
    }
    msgsnd(msgid,&sendBuf,strlen(sendBuf.mtext),0);
    printf("sending success\n");
    msgctl(msgid,IPC_RMID,NULL);




    return 0;
}

msgGet
#include<stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
//ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);
                      
struct msgBuf{
    long mtype;
    char mtext[128];
};
int main()
{
    /*
    1获取消息队列
    2读取消息
    */
    key_t key = ftok(".",1);
    if (key != -1)
    {
        printf("key:%x\n",key);
    }
    int msgid = msgget(key,IPC_CREAT|0777);
    
    struct msgBuf readBuf;

    if (msgid == -1)
    {
        printf("get queue failed\n");
    }
    else
    {
        printf("get queue success\n");
        printf("queue id:%d\n",msgid);
    }
    msgrcv(msgid,&readBuf,sizeof(readBuf.mtext),778,0);
    printf("receive from queue:%s\n",readBuf.mtext);
    msgctl(msgid,IPC_RMID,NULL);
    






    return 0;
}

验证结果：
在这里插入图片描述
在这里插入图片描述

共享内存

过程

1获取/创建共享内存
2读写进程分别把共享内存挂载到各自的地址空间里
3根据利用strcpy把消息复制到共享内存中
4读进程把消息读出

API

int shmget(key_t key, size_t size, int shmflg);
跟消息队列一样，共享内存也需要key值，第二个参数为共享内存的大小，在设置时必须设置成兆的整数倍，最后一个是获取共享内存的方式，通常设置成IPC_CREAT并带上操作权限，成功返回内存ID，不成功返回-1
void *shmat(int shmid, const void *shmaddr, int shmflg);
挂载函数：把创建成功的shmid号共享内存挂载到进程的地址空间中，最后一个参数默认0为可读可写权限
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
对共享内存进行操作
int shmdt(const void *shmaddr);
卸载掉已挂载的共享内存（不是删除）

编程实现

#include<stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include<stdlib.h>
//int shmget(key_t key, size_t size, int shmflg);
//void *shmat(int shmid, const void *shmaddr, int shmflg);
//int shmctl(int shmid, int cmd, struct shmid_ds *buf);
//int shmdt(const void *shmaddr);
int main()
{
    key_t key;
    int shmid;
    char *shmaddr = NULL;
    key = ftok(".",2);
    shmid = shmget(key,1024*4,0);
    if(shmid == -1){
        printf("shmget failed\n");
        exit(-1);
    }
    shmaddr = shmat(shmid,0,0);
    printf("allocate success\n");

    printf("data:%s\n",shmaddr);
    shmdt(shmaddr);
    shmctl(shmid,IPC_RMID,0);
    printf("quit\n");
    return 0;
}

#include<stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include<stdlib.h>
//int shmget(key_t key, size_t size, int shmflg);
//void *shmat(int shmid, const void *shmaddr, int shmflg);
//int shmctl(int shmid, int cmd, struct shmid_ds *buf);
//int shmdt(const void *shmaddr);
int main()
{
    key_t key;
    int shmid;
    char *shmaddr = NULL;
    key = ftok(".",2);
    shmid = shmget(key,1024*4,0);
    if(shmid == -1){
        printf("shmget failed\n");
        exit(-1);
    }
    shmaddr = shmat(shmid,0,0);
    printf("allocate success\n");

    printf("data:%s\n",shmaddr);
    shmdt(shmaddr);
    shmctl(shmid,IPC_RMID,0);
    printf("quit\n");
    return 0;
}

结果演示
在这里插入图片描述

信号：软中断

对信号有3种处理方式：忽略，捕捉信号，系统默认动作
编程演示：运行程序时键盘按下CTRL+C无效

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

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

void handler(int signum)
{
    printf("get signum : %d\n",signum);
    printf("SIGINT\n");
}

int main()
{
    signal(SIGINT,handler);//注册信号捕捉函数，第一个参数对应需要捕捉的信号编号，第二个为回调函数指针指向捕捉信号后需要执行的函数
    while(1);

    return 0;
}

在这里插入图片描述
在主函数注册信号捕捉函数并定义回调函数之后，在程序运行过程中一旦接收到注册的信号就会指向在主函数外定义的函数并执行所定义的函数
以上所说的函数仅能针对当信号触发时系统的行为
更高级的sigaction函数可以在传输信号时携带信息
关心两个问题：
对于发送端：用什么发以及如何放入信息
对于接收端：用什么收以及如何读出发送端的信息

#include <signal.h>

int sigaction(int signum, const struct sigaction *act,
                     struct sigaction *oldact);
struct sigaction {
               void     (*sa_handler)(int);
               void     (*sa_sigaction)(int, siginfo_t *, void *);
               sigset_t   sa_mask;
               int        sa_flags;
               void     (*sa_restorer)(void);
           };

返回值为int型的信号捕捉函数，指定捕获的信号，并执行新的操作，最后一个变量为备份旧操作，如不需要备份赋NULL值即可
定义操作结构体时需要设置一下参数：
1捕捉信号后需要执行的操作（不接收数据）
2信号处理程序，能接受额外数据
3阻塞关键字的信号集
4影响信号的行为标志位
5保留字段，一般设NULL值（已被弃用）

步骤：
首先与初级信号函数一样我们均需要对捕获信号后所需要进行的动作进行定义，要实现收发消息，需要在act结构体中把sa_flag设置为SA_SIGINFO来使能数据接收功能，并且要在设置信号处理函数时设置成sigaction选项，并且要在发送消息的程序中设置好发送的数据或者信息
示例程序：

#include<stdio.h>
#include<signal.h>
//接收端程序
void handler(int signum,siginfo_t *info,void *context)
{
    printf("%d process send message\n",signum);
    if(context != NULL){
        printf("get data : %d\n",info->si_value.sival_int);
    }
}
int main()
{
    struct sigaction act;
    act.sa_sigaction = handler;
    act.sa_flags = SA_SIGINFO;

    sigaction(SIGUSR1,&act,NULL);
    while(1);
    return 0;
}

#include<signal.h>
#include<stdio.h>
#include<stdlib.h>
//发送端程序

int main(int argc,char **argv)
{
    int pid = atoi(argv[1]);
    int signum = atoi(argv[2]);
    union sigval value;
    value.sival_int = 100;
    sigqueue(pid,signum,value);
    printf("done\n");

}

实际运行效果
在这里插入图片描述

信号量（进程同步）

本质就是一个计数器，用来在临界资源使用中使多个进程操作互斥或者同步
拿生活中的例子来说：只有一台打印机，两个人都想同时用，人为规定只能一个人用完另一个人用，于是就把打印机锁上了，并配备一把钥匙，需要用的时候开锁，用完把钥匙放回等下一个人用。这里的打印机就是临界资源，而钥匙和锁就是信号量的表示
PV操作：原子操作：一旦开始执行必须执行完，不能中断
P操作：信号量减一（拿钥匙）
V操作：信号量加一（放回钥匙）
编程演示：调用linux相关的api来实现信号量的应用

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>
//int semget(key_t key, int nsems, int semflg);
//int semctl(int semid, int semnum, int cmd, ...);
//int semop(int semid, struct sembuf *sops, size_t nsops);指定信号量数组的ID，并在结构体中设置好操作参数，最后设置操作个数
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) */
};
//保证子进程比父进程先运行（不使用wait函数的情况下）
void PGetKey(int id)
{
    struct sembuf set;
    set.sem_num = 0;//操作信号量编号
    set.sem_op = -1;//信号量操作数（变化）
    set.sem_flg = SEM_UNDO;
    semop(id,&set,1);
    printf("get the key!\n");
}
void VReturnKey(int id)
{
    struct sembuf set;
    set.sem_num = 0;
    set.sem_op = 1;
    set.sem_flg = SEM_UNDO;
    semop(id,&set,1);
    printf("return the key!\n");
}
int main()
{
    key_t key;
    key = ftok(".",2);

    int semid = 0;
    union semun initsem;
    initsem.val = 0;
    semid = semget(key,1,IPC_CREAT|0666);//获取或创建信号量数组并指定信号量数组中信号量个数
    if(semid != -1){
        printf("semophore create success\n");
        printf("semid:%d\n",semid);
    }
    semctl(semid,0,SETVAL,initsem);//信号量数组赋初值或其他操作

    pid_t pid = fork();
    if(pid > 0){
        PGetKey(semid);
        printf("this is father \n");
        VReturnKey(semid);
        semctl(semid,0,IPC_RMID);
    }
    else if(pid == 0){
        printf("this is child\n");
        VReturnKey(semid);
    }
    else{
        printf("fork error\n");
    }
    return 0;
}

当初始信号量为0时，父进程因为拿不到钥匙而阻塞，而子进程通过一些特殊途径拿到一把钥匙并且把钥匙还回去了，从而使父进程可以拿到钥匙并且运行，由此可以实现不调用wait函数实现让子进程先运行父进程后运行

延14
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
（三）Linux系统编程之进程间通信
CarmenIsOK的博客
05-07 545
1.什么是IPC a.进程间通信 i.InterProcess Communication 2.进程间通信常用的4种方式 a.管道-简单 b.信号-系统开销小 c.共享映射区 -（有无血缘关系的进程间通信都可以） d.本地套接字 - 稳定 由于每个进程都有各自不同的用户地址空间，任何一个进程的全局变量在另一个进程中都看不见，所以进程之间要减缓数据必须通过内核，在内核中开辟一块缓冲区。内核提供这种机...
Linux系统编程_进程间通信
chmod_a的博客
12-29 92
IPC通信方式
进程间通信编程
weixin_43296982的博客
03-05 1213
1.进程间通信方式概述 进程间通信是在不同进程之间传播或者交换信息。 进程间通信方法有:管道(无名和有名管道)，消息队列，信号量，共享内存，信号，套接字等 进程间通信的目的: 1、数据传输，2、共享数据，3、通知事件，4、资源共享，5、进程控制 2.管道通信 管道有无名管道和有名管道，无名管道是适用于父子进程或者兄弟进程之间，进程之间存在联系的，可以用管道。 有名管道，不仅父子，兄弟进程可以使用，没有关系的两个进程也可以使用，有名管道克服了管道没有名字的限制。所以才可以字无关系的进程之间建立通信。传递的数据
Linux系统编程--(三)进程间通信
leafgood的博客
12-06 162
Linux系统编程--(三)进程间通信
linux 进程与线程
u010059939的专栏
05-30 220
进程与线程 为什么对于大多数合作性任务，多线程比多个独立的进程更优越呢？这是因为，线程共享相同的内存空间。不同的线程可以存取内存中的同一个变量。所以，程序 中的所有线程都可以读或写声明过的全局变量。如果曾用fork() 编写过重要代码，就会认识到这个工具的重要性。为什么呢？虽然fork() 允许创建多个进程，但它还会带来以下通信问题:如何让多个进程相互通信，这里每个进程都有各自独立的内存空间。对这个问题没有一个简单的答案。虽然有许多不同种类的本地IPC (进程间通信），但它们都遇到两个重要障碍： 强加.
Linux系统编程之进程间通信方式介绍
m0_67664970的博客
06-07 340
通信方式效果无名管道速度慢，容量有限，只有父子进程能通讯命名管道 （FIFO）任何进程间都能通讯，但速度慢消息队列容量受到系统限制，且要注意第一次读的时候，要考虑上一次没有读完数据的问题共享内存能够很容易控制容量，速度快，但要保持同步，比如一个进程在写的时候，另一个进程要注意读写的问题，相当于线程中的线程安全，当然，共享内存区同样可以用作线程间通讯，不过没这个必要，线程间本来就已经共享了同一进程内的一块内存信号。
138 Linux 系统编程15 进程间通讯IPC ，：管道pipe函数用于血缘关系的进程间通讯，FIFO有名管道，使用文件完成进程间通讯，共享存储映射使用mmap 函数
hunandede的博客
03-01 838
任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）。IPC 原理是因为：在MMU 管理 虚拟内存和物理内存的时候，实际上所有程序的kernel都会被映射到同一块 物理内存，因此才可以在这个同一块的 物理 内存中，建立一块缓冲区，然后让a 和 b 通讯。
Linux系统编程-进程间通信1
08-08
在Linux系统编程中，进程间通信（IPC，InterProcess Communication）是实现不同进程间数据交换的关键技术。由于每个进程都有其独立的用户地址空间，它们无法直接访问彼此的数据。为了解决这个问题，操作系统提供了...
linux系统编程-进程间通信
04-19
Linux 系统编程 - 进程间通信 Linux 系统编程中，进程间通信（IPC）是指不同的进程之间交换数据和信息的机制。由于每个进程都有其自己的用户地址空间，所以进程之间不能直接访问对方的变量，需要通过内核提供的机制...
Linux系统编程实验六进程间通信.pdf
11-01
【Linux系统编程实验六进程间通信】 实验六的目的是让学生掌握Linux系统中进程间通信（IPC，Inter-Process Communication）的不同方法，包括无名管道、有名管道、信号以及消息队列。这些通信机制是多进程应用程序...
VC++ 四种进程间通信的完整实例
05-11
VC++ 四种进程间通信的完整实例，一般来说，进程通信采取四种形式：剪贴板、匿名管道、命名管道、邮槽。孙鑫将带你用实例来验证这四种方式的优略性，进而帮助VC编程者熟悉掌握进程间通信的方方面面，并附有孙鑫老师的讲义，欢迎参阅。
Linux系统编程实验六进程间通信.docx
11-01
在本实验中，我们主要探讨了Linux系统编程中的两个核心概念：进程间通信（IPC，Inter-Process Communication）以及信号处理。实验环境是基于Linux的虚拟机，通过编写C语言程序来实现这些功能。 首先，我们关注的是...
LINUX系统编程之进程间通信机制
11-21
LINUX系统编程下进程间通信机制,pdf格式，对理解进程间的通信很重要
Linux进程间通信的五种方式
qq_38813765的博客
09-20 2837
一、管道一、管道二、 信号三、共享内存四、消息队列五、信号量。
Linux应用编程：管道通信
weixin_43547900的博客
09-05 176
管道(pipe)是一种单向且先进先出形式的通信方式，一个进程向管道的尾部写入数据，而另一个进程从管道的头部读出数据，所以把这种通信方式比喻成管子再合适不过了。 管道分为无名管道和有名管道两种 无名管道 名字上可以知道无名管道是没有标识的管道，其仅仅只能用于父子进程等具有血缘关系的进程通信，管道可以看成特定的文件，对于无名管道而言在文件系统中不可见，只存于内存中。 有名管道 有名管道算是无名管道的改进，由于无名管道通信限制较大，因此有名管道可以在任意两个进程中进行通信，该管道可以通过路径名来指出，且
Linux系统进程间通信编程
weixin_55179981的博客
10-26 216
进程间通信
Linux系统编程——进程间的通信
NRWHF的博客
11-10 903
Linux系统编程——进程间的通信
linux系统编程之进程间的通信
qq_53918454的博客
11-26 684
1.无名管道：速度慢，容量有限，只有亲缘进程之间才能通信；2.有名管道：速度慢，但是任何进程间都能通信；3.消息队列：容量受系统限制，第一次读时，要考虑上次没有读完的数据问题；4.共享内存：能够容易控制容量，速度快，但要考虑同步问题；5.信号量：用来同步消息；以上就是进程间通信相关内容，有不对的地方欢迎大家批评指正。
【linux/shell】linux如何去除字符串中空格
最新发布
qq_35902025的博客
07-06 408
linux如何去除字符串中空格 tr命令可以用来替换或删除字符 sed是一个流编辑器，可以用来处理文本
linux系统进程间通信
12-20
Linux系统提供了多种进程间通信的方式，包括管道、消息队列、信号量、共享内存和Socket等。 1. 管道（Pipe）是一种最简单的进程间通信方式。它分为无名管道和命名管道。无名管道只能在具有亲缘关系的进程之间使用，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值