Linux 编程基础——进程间通信

最新推荐文章于 2023-08-08 20:29:13 发布
最新推荐文章于 2023-08-08 20:29:13 发布
阅读量523 收藏 5
点赞数
文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52008889/article/details/124804472
版权

管道

管道通信的流程：在一个进程中创建管道，创建子进程，关闭多余端口，使父子进程形成单向通道，进行数据传输。

创建匿名管道函数：

#include <unistd.h>
int pipe(int pipefd[2]);

示例：使用pip实现父子进程间通信，子进程作为写端，父进程读出内容并打印到终端。

解释:用到的write(int fd,const void *buf,size_t count)函数：把参数buf所指的内存写入count个字节到所指的文件fd内。

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

int main(){
    int tempFd[2];//定义文件描述符数组
    int tempRet=pipe(tempFd);//创建管道
    if(tempRet == -1){
        perror("pipe");
        exit(1);
    }
    pid_t tempPid=fork();
    if(tempPid > 0){//父进程—读
        close(tempFd[1]);//关闭写端
        char tempBuf[64]={0};
        tempRet = read(tempFd[0], tempBuf, sizeof(tempBuf));//读数据
        close(tempFd[0]);
        write(STDOUT_FILENO, tempBuf, tempRet);//将读到的数据写到标准输出
        wait(NULL);
    } else if(tempPid == 0){//子进程—写
        close(tempFd[0]);//关闭读端
        char *tempStr="There is content:hello,pipe\n";
        write(tempFd[1], tempStr, strlen(tempStr)+1);//写数据
        close(tempFd[1]);
   }//of if
   return 0;
}//of main

输出结果：子进程将内容写入管道，父进程从管道读出内容。

重定向函数：将参数oldfd的文件描述符传递给newfd

#include <unistd.h>
int dup2(int oldfd, int newfd);

示例：使用管道完成兄弟间通信，实现命令 ls | wc -l

解释一下命令 ls|wc-l 实现的功能：ls列出当前文件夹下的文件，通过管道传递内容实现统计管道传来的文件数量,如下：

通过代码程序实现命令功能：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(){
    int tempFd[2];
    int tempRet = pipe(tempFd);
    if(tempRet == -1){
        perror("pipe err");
        exit(1);
    }//of if   
    int i;
    pid_t tempPid, tempWpid;
    for(i=0; i<2; i++){//2个子
        if((tempPid = fork()) == 0){
            break;
        }//of if
    }//of if
	if(2 == i){//父进程，回收子进程
        close(tempFd[0]); //关闭读
        close(tempFd[1]); //关闭写
        tempWpid = wait(NULL);
        printf("wait child 1 success,pid=%d\n", tempWpid );
        tempPid = wait(NULL);
        printf("wait child 2 success,pid=%d\n", tempPid);
    } else if(0 == i){//子进程1—写
        close(tempFd[0]);
        dup2(tempFd[1], STDOUT_FILENO);//定向到标准输出
        execlp("ls", "ls", NULL);
    } else if(1 == i){//子进程2—读
        close(tempFd[1]);
        dup2(tempFd[0], STDIN_FILENO);
        execlp("wc", "wc", "-l", NULL);
    }//of if
    return 0;
}//of main

 运行结果：

linux标准I/O库中封装的两个函数完成管道通信：

#include <stdio.h>
//创建管道，创建子进程，调用shell命令
FILE *popen(const char *command, const char *type);

//关闭popen打开的I/O流，等待子进程执行结束，返回终止状态
int pclose(FILE *stream);

示例：通过调用函数实现管道通信，实现 ls | wc -l

解释用到的函数：

//从文件读取一行送到缓冲区的首地址s,size是缓冲区的长度
char *fgets(char *s,int size,FILE *stream)

//向指定文件写入一个字符串
int fputs(const char *s,FILE *stream)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(){
    FILE *tempRfp,*tempWfp;
    char temBuf[100];
    tempRfp = popen("ls","r");		//读取命令执行结果
    tempWfp = popen("wc -l","w");	//将管道中的数据传递给进程
    while(fgets(temBuf, sizeof(temBuf), tempRfp)!=NULL){
    	fputs(temBuf, tempWfp);
    }//of while   
    pclose(tempRfp);
    pclose(tempWfp);
    return 0;
}//of main

运行结果：

命名管道（FIFO）：

匿名管道没有名字，只能用于有亲缘关系的进程间通信。

命名管道与系统中的路径名关联，以文件形式存在，系统中的不同进程可以通过路径名访问文件实现通信。

创建命名管道函数：

#include <sys/type.h>
#include <sys/stat.h>

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

示例：创建命名管道实现没有亲缘关系的进程间通信。

解释：使用fork()函数创建进程有亲缘关系，所以这里不能使用fork()函数创建进程，通过两段程序实现。

第一段：w.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 paraArgc,char *paraArgv[]){
    if(paraArgc < 2){							//判断是否传入文件名
        printf("./a.out fifoname\n");
        exit(1);
    }//of if
    int tempRet = access(paraArgv[1], F_OK);	//判断fifo文件是否存在
    if(tempRet == -1){							//若fifo不存在就创建fifo 
        int tempFIFO = mkfifo(paraArgv[1], 0664);
        if(tempFIFO == -1){						//判断文件是否创建成功
            perror("mkfifo");
            exit(1);
        } else{
            printf("fifo creat success!\n");
        }//of if
    }//of if
   int tempFd = open(paraArgv[1], O_WRONLY);		//读写方式打开
   while(1){									//循环写入数据
        char *tempStrp="hello,world!";
        write(tempFd, tempStrp, strlen(tempStrp)+1);
        sleep(1);
    }//of while
    close(tempFd);
    return 0;
}//of main

第二段：r.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 paraArgc,char *paraArgv[]){
    if(paraArgc < 2){						//判断是否传入文件名
        printf("./a.out fifoname\n");
        exit(1);
    }//of if
    int tempRet = access(paraArgv[1], F_OK);	//判断fifo文件是否存在
    if(tempRet == -1){						//若fifo不存在就创建fifo 
        int tempFIFO = mkfifo(paraArgv[1], 0664);
        if(tempFIFO == -1){					//判断文件是否创建成功
            perror("mkfifo");
            exit(1);
        } else{
            printf("fifo creat success!\n");
        }//of if
    }//of if
    int tempFd = open(paraArgv[1], O_RDONLY);	//只读方式打开
    if(tempFd == -1){
        perror("open");
        exit(1);
    }//of if
    while(1){								//不断读取fifo中的数据并打印
        char temBuf[1024]={0};
        read(tempFd, temBuf, sizeof(temBuf));
        printf("buf=%s\n", temBuf);
    }//of while
    close(tempFd);							//关闭文件
    return 0;
}//of main

运行结果：w.c程序中使进程每隔一秒向管道中写入一条数据，r.c进程在终端每隔一秒读出打印信息。

消息队列

消息队列实现进程间通信流程：创建消息队列，发送消息到消息队列，从消息队列中读取数据，删除消息队列。

可以通过系统调用实现上面的流程：

//创建消息队列，返回值为该队列号
int msgget(key_t key, int msgflg); 

//向指定消息队列发送消息
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

//接受信息，msgtyp需要指明接受的数据type
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg

//为队列随机附加key，pathename为路径，id号可随意（1-255）
key_t ftok(const char *pathname, int proj_id);

//对指定消息队列进行控制
int msgctl(int msqid, int cmd, struct msqid_ds *buf);

示例：使用消息队列实现不同进程间通信。

两段代码依次为send.c和recive.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/msg.h>
#include <string.h>
#define MAX_TEXT 512
//消息结构体
struct my_msg_st{
	long int my_msg_type;       				//消息类型
	char anytext[MAX_TEXT];     				//消息数据
};
int main() {
	int tempIdx = 1;
	int tempMsgid;
	struct my_msg_st tempData;
	char tempBuf[BUFSIZ];						//设置缓存变量
	tempMsgid = msgget((key_t)1000, 0664 | IPC_CREAT);//创建消息队列
	if (tempMsgid == -1){
		perror("msgget err");
		exit(-1);
	}//of if
	while (tempIdx < 5){							//发送消息
		printf("enter some text:");
		fgets(tempBuf, BUFSIZ, stdin);
		tempData.my_msg_type = rand() % 3 + 1;        	//随机获取消息类型
		strcpy(tempData.anytext, tempBuf);
		//发送消息
		if (msgsnd(tempMsgid, (void*)&tempData, sizeof(tempData), 0) == -1){
			perror("msgsnd err");
			exit(-1);
		}//of if
		tempIdx ++;
	}//of while
	return 0;
}//of main

#include <stdio.h>
#include <stdlib.h>
#include <sys/msg.h>
#define MAX_TEXT 512
struct my_msg_st{
	long int my_msg_type;
	char anytext[MAX_TEXT];
};
int main(){
	int tempIdx = 1;
	int tempMsgid;
	struct my_msg_st tempData;
	long int tempMsgToRcv = 0;
	//rcv msg
	tempMsgid = msgget((key_t)1000, 0664 | IPC_CREAT);//获取消息队列
	if (tempMsgid == -1){
		perror("msgget err");
		exit(-1);
	}//of if
	while (tempIdx < 5){
		//接收消息
		if (msgrcv(tempMsgid, (void*)&tempData, BUFSIZ, tempMsgToRcv, 0) == -1){
			perror("msgrcv err");
			exit(-1);
		}//of if
		//打印消息
		printf("msg type:%ld\n", tempData.my_msg_type);
		printf("msg content is:%s", tempData.anytext);
		tempIdx ++;
	}//of while
	//删除消息队列
	if (msgctl(tempMsgid, IPC_RMID, 0) == -1){
		perror("msgctl err");
		exit(-1);
	}//of if
	exit(0);
}//of main

运行结果：每当输入一条信息，接收进程会打印出其内容，在程序中使用了循环限制，因此四条后进程终止。

信号量

不同的进程通过获取同一个信号量键值进行通信，实现进程间对资源的互斥访问。

使用信号量进行通信流程：创建或者获取信号量/信号集，初始化信号量，执行信号量P、V操作根据进程请求修改信号量数量,从系统中删除不需要的信号量。

三个系统调用接口实现以上流程：

//创建或获取信号量/信号集
#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);

//控制信号量/信号集
#include <sys/sem.h>
int semctl(int semid, int semnum, int cmd, ...);

//改变信号量的值
#include <sys/sem.h>
int semop(int semid, struct sembuf *sops, unsigned nsops);

示例：使用信号量实现父子进程同步，防止父子进程抢夺CPU。

#include <stdio.h>
#include <stdlib.h>
#include <sys/sem.h>
#include <unistd.h>
#include <sys/wait.h>

//自定义共用体,使用semctl()函数参数cmd需要自定义共同体
union semu{
	int val;                     
	struct semid_ds* buf;
	unsigned short* array;
	struct seminfo* _buf;
};

static int semId;

//设置信号量值
static int setSemValue() {
	union semu tempSemUnion;
	tempSemUnion.val = 1;
	if (semctl(semId, 0, SETVAL, tempSemUnion) == -1){
		return 0;
	}//of if
	return 1;
}//of setSemValue

//p操作，获取信号量
static int semaphoreP() {
	struct sembuf tempSemBuf;
	tempSemBuf.sem_num = 0;
	tempSemBuf.sem_op = -1;
	tempSemBuf.sem_flg = SEM_UNDO;
	if (semop(semId, &tempSemBuf, 1) == -1){
		perror("sem_p err");
		return 0;
	}//of if
	return 1;
}//of semaphoreP

//V操作，释放信号量
static int semaphoreV() {
	struct sembuf tempSemBuf;
	tempSemBuf.sem_num = 0;
	tempSemBuf.sem_op = 1;
	tempSemBuf.sem_flg = SEM_UNDO;
	if (semop(semId, &tempSemBuf, 1) == -1){
		perror("sem_v err");
		return 0;
	}//of if
	return 1;
}//of semaphoreV

//删除信号量
static void delSemValue() {
	union semu tempSemUnion;
	if (semctl(semId, 0, IPC_RMID, tempSemUnion) == -1){
		perror("del err");
	}//of if
}//of delSemValue

int main() {
	int i;
	pid_t temPid;
	char tempChar = 'C';
	semId= semget((key_t)1000, 1, 0664 | IPC_CREAT);//创建信号量
	if (semId== -1){
		perror("sem_c err");
		exit(-1);
	}//of if
	if (!setSemValue()){					//设置信号量值
		perror("init err");
		exit(-1);
	}//of if
	temPid = fork();								//创建子进程
	if (temPid== -1){								//若创建失败
		delSemValue();						//删除信号量
		exit(-1);
	} else if (temPid == 0){     						//设置子进程打印的字符
		tempChar = 'Z';
	} else {										//设置父进程打印的字符
		tempChar = 'C';
	}//of if
	srand((unsigned int)getpid());			//设置随机数种子
	for (i = 0; i < 8; i++)	{						//循环打印字符
		semaphoreP();						//获取信号量
		printf("%c", tempChar);
		fflush(stdout);						//将字符打印到屏幕
		sleep(rand() % 4);						//沉睡
		printf("%c", tempChar);
		fflush(stdout);						//再次打印到屏幕
		sleep(1);
		semaphoreV();						//释放信号量
	}//of for i
	if (temPid > 0){
		wait(NULL);							//回收子进程
		delSemValue();						//删除信号量
	}else{
	    printf("\nI'm child,my ppid is: %d\n",getppid());
	}//of if
	printf("\nprocess %d finished.\n", getpid());
	return 0;
}//of main

运行结果：

 解释：使用semaphoreP()获取信号量，若获取信号量的是父进程，那么子进程无法获取CPU，除非父进程调用semaphoreV()释放信号量，子进程也是一样。因此循环内的两次打印操作为同一个结果，即打印结果的成对出现。打印z结束即子进程此时占有CPU，子进程执行完代码先结束，CPU分配给父进程父进程继续执行代码至结束。

共享内存

linux内核提供了相关系统调用函数：

//创建或打开一块共享内存
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);

//将共享内存映射到进程虚拟地址空间中
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);

//解除物理内存与进程虚拟地址的映射关系
#include <sys/shm.h>
int shmdt(const void *shmaddr);

//对已经存在的共享内存进行操作
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

示例：创建两个进程，使用共享内存机制实现进程间通信。

两段代码程序shw.c和shr.c

第一段shw.c：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#define SEGSIZE 4096			//定义共享内存容量

typedef struct{					//读写数据结构体
	char name[8];
	int age;
} Stu;
int main() {
	int tempShmId, i;
	key_t tempKey;
	char tempName[8];
	Stu *tempSmap;
	/*ftok函数的作用：系统建立IPC通讯（如消息队列、共享内存时）必须指定一个ID值。通常情况下，该id值通过ftok函数得到。*/
	tempKey = ftok("/", 0);			//获取关键字
	if (tempKey == -1) {
		perror("ftok error");
		return -1;
	}//of if
	printf("key=%d\n", tempKey);
	//创建共享内存
	tempShmId= shmget(tempKey, SEGSIZE, IPC_CREAT | IPC_EXCL | 0664);
	if (tempShmId == -1) {
		perror("create shared memory error\n");
		return -1;
	}//of if
	printf("shm_id=%d\n", tempShmId);
	tempSmap = (Stu*)shmat(tempShmId, NULL, 0);	//将进程与共享内存绑定
	memset(tempName, 0x00, sizeof(tempName));
	strcpy(tempName, "Jhon");
	tempName[4] = '0';
	for (i = 0; i < 3; i++){					//写数据
		tempName[4] += 1;
		strncpy((tempSmap+ i)->name, tempName, 5);
		(tempSmap + i)->age = 20 + i;
	}//of for i
	if (shmdt(tempSmap) == -1){					//解除绑定
		perror("detach error");
		return -1;
	}//of if
	return 0;
}//of main

第二段shr.c：

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

typedef struct{
	char name[8];
	int age;
} Stu;
int main() {
	int tempShmId, i;
	key_t tempKey;
	Stu *tempSmap;
	struct shmid_ds tempBuf;
	tempKey = ftok("/", 0);				//获取关键字
	if (tempKey == -1) {
		perror("ftok error");
		return -1;
	}//of if
	printf("key=%d\n", tempKey);
	tempShmId = shmget(tempKey, 0, 0);		//创建共享内存
	if (tempShmId == -1) {
		perror("shmget error");
		return -1;
	}//of if
	printf("shm_id=%d\n", tempShmId);
	tempSmap = (Stu*)shmat(tempShmId, NULL, 0);	//将进程与共享内存绑定
	for (i = 0; i < 3; i++){					//读数据
		printf("name:%s\n", (*(tempSmap + i)).name);
		printf("age ：%d\n", (*(tempSmap + i)).age);
	}//of for i
	if (shmdt(tempSmap) == -1){					//解除绑定
		perror("detach error");
		return -1;
	}//of if
	shmctl(tempShmId, IPC_RMID, &tempBuf);			//删除共享内存
	return 0;
}//of main

运行结果：执行第一段程序创建共享内存并写入数据，执行第二段程序读取数据且读取后删除共享内存，因此再次执行读取数据程序看到无法找到共享内存。

DemonsYZ
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux系统编程之父子进程通过管道进行通信
qq_42547076的博客
08-12 8380
Linux系统编程之父子进程通过管道进行通信管道通信1.pipe函数2.父子进程通过管道通信步骤3.创建一个父子进程通信管道4.利用进程间通信实现ls | wc -l 指令5.兄弟进程间通过管道通信 管道通信 1.pipe函数 创建管道 int pipe(int pipefd[2]); 返回值成功：0；失败：-1，设置 errno 函数调用成功返回 r/w 两个文件描述符。无需 open，但需手动 close。 规定： fd[0] → r； fd[1] → w， 就像 0 对应标准输入，1 对应标准
linux 进程 stdout,linux c语言 重定向子进程的stdout（标准输出）
weixin_34420941的博客
05-01 633
程序简介：1.建立有名管道2.在子進程里打开寫端，以及利用dup2()函數將stdout重定向到有名管道3.跟着在子進程里使用execl()函數調用/bin/ls4.在父進程里打開讀端，讀取子進程裏的標準輸出數據，也就識/bin/ls輸出得數據#include #include #include #include #include #include #define FIFO "stdout_fif...
管道编程
weixin_33711641的博客
02-07 106
管道是一个允许单向信息传递的通信设备。从管道“写入端”写入的数据可以从“读取端”读回。管道是一个串行设备；从管道中读取的数据总保持它们被写入时的顺序。一般来说，管道通常用于一个进程中两个线程之间的通信，或用于父子进程之间的通信。 在shell 中，| 符号用于创建一个管道。例如，下面的程序会使 shell 创建两个子进程，一个运行ls而一个运行less： % ls | less Shell同时还...
linux管道编程（实验4）
JZ_TONGXIE
06-16 8253
linux管道编程 1.实验目的 ①　了解与掌握linux操作系统的基本操作 ②　了解并掌握管道的工作原理 2.实验平台 操作系统：Linux 3.实验内容和要求 （一）操作实验任务 ①　熟悉采用命令ln在文件与目录之间创建链接 ②　掌握硬链接和软链接的区别 ③　首先在/opt目录下建立一个文件夹test_ln,然后将/tmp/file_temp/file1.txt 建立硬链接到/opt/test_ln ④　将/tmp/file_temp/file1.txt 建立软链接到/opt/test_ln ⑤　阅读附
Linux编程：两个无名管道实现父子进程双向通信，实现父子进程轮流叠加数字
HKH368的博客
02-15 1143
初步代码：验证管道中是否可以直接存储或读取iint型数据 1 #include<stdio.h> 2 #include<sys/types.h> 3 #include<unistd.h> 4 #include<stdlib.h> 5 #include<string.h> 6 int main(int argc,char const*argv[]) 7 { 8 pid_t pid; 9 i...
Linux系统编程实验六进程间通信.docx
11-01
在本实验中，我们主要探讨了Linux系统编程中的两个核心概念：进程间通信（IPC，Inter-Process Communication）以及信号处理。实验环境是基于Linux的虚拟机，通过编写C语言程序来实现这些功能。 首先，我们关注的是...
Linux进程间通信--使用信号
09-15
总结来说，Linux中的信号机制为进程间通信提供了一种基础且灵活的方法，允许进程对系统事件或来自其他进程的信号做出反应。通过合理使用`signal`和`sigaction`函数，可以定制化信号处理行为，从而实现复杂的应用场景...
linux进程间通信——信号机制
11-04
在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是实现多个进程协同工作的重要手段。其中，信号（Signal）是一种轻量级、异步的通信方式，它允许一个进程向另一个进程发送一个通知，表明某个...
操作系统原理实验-进程间通信
12-29
操作系统原理实验——进程间通信是计算机科学中一个关键的话题，特别是在多任务环境下，理解并实践进程间的通信机制至关重要。在本实验中，我们主要关注的是通过内存共享来实现进程间的实际通信，区别于单进程中的伪...
进程间通信——匿名管道
01-06
总结来说，匿名管道是进程间通信的基础工具，尤其适用于简单的单向通信场景。尽管它的功能有限，但其高效和简洁的特性使其在许多早期的系统设计中占据一席之地。理解并熟练掌握匿名管道的使用，对于深入理解操作系统...
管道的破裂pipe_broken
本人喜欢编程（c/c++/嵌入式/单片机硬件制作）、听音乐、偶尔看电影、看书、爱研究、有好奇心
08-29 391
管道的破裂pipe_broken
Linux | 进程间通信：信号量
m0_56194716的博客
06-11 951
信号量sem为一个特殊变量（通常取正值），代表可用资源数目，由内核直接管理。信号量是用来控制同步进程的。【信号量的pv操作】：信号量减一代表获取资源可能阻塞（信号量为0时）（p操作）信号量加一代表释放资源（v操作）同步进程（对程序的执行进行控制）。信号量只取0和1：二值信号量；信号量的取值>1：计数信号量（资源信号量）。
C 语言编程 — 管道操作
热门推荐
烟云的计算
05-16 1万+
目录 文章目录目录Linux 的管道指令C 语言的匿名管道命名管道匿名管道和命名管道的区别参考文档 Linux 的管道指令 如果你熟悉 Linux，那么你对管道应该不会感到陌生，我们经常会使用 “|” 来使用管道。但是管道的真正定义是什么呢？ 管道是一个进程连接数据流到另一个进程的通道，它通常用作把一个进程的输出通过管道连接到另一个进程的输入。 例如：ls -l | grep string。 C 语言的匿名管道 C 语言的匿名管道 pipe() 定义在头文件 unistd.h 中。 int pipe(f
【实验一】Linux的共享内存和信号量
一指流沙的博客
05-06 773
一、共享内存的使用流程 ①ftok函数生成键值 ②shmget函数创建共享内存空间 ③shmat函数获取第一个可用共享内存空间的地址 ④shmdt函数进行分离（对共享存储段操作结束时的步骤，并不是从系统中删除共享内存和结构） ⑤shmctl函数进行删除共享存储空间 函数参考一下博客 (1条消息) Linux下共享内存编程（共享存储空间）_小牛CKX的博客-CSDN博客_创建共享内存https://blog.csdn.net/qq_27664167/article/details/8127709
Linux之进程间通信
cls的博客
03-22 2177
共享内存在内核中申请的基本单位是页，这个页叫做内存页，这个内存页叫做4KB。如果我申请4097个字节，内核会向上取整，给你4096byte*2（多要了一个就得多申请一页，因为没有4097）。但是我们实际看到的并不是4096*2，而是4097，这又是怎么回事呢？如果我向OS要了10个字节，OS只给了9个，我就认为是错的，因为很容易发生越界，OS就有问题。
【Linux】-- 进程间通信
最新发布
局部变量和全局变量
08-08 1180
之前学习的进程，都是各自运行，互不干扰，进程之间没有协同。然而有许多场景下是需要进程之间相互协同的，由于进程是程序员写的，因此进程之间的协同本质上就是程序员之间的协同，比如一个程序员从数据库里面拿数据，另一个程序员要把从数据库里面拿到的数据进行格式化，写成特定格式，还有一个程序员根据格式化的数据进行统计，如果把这些工作量当成意见工作去处理的话，如果其中这三个环节有任何一个环节出错了，那么这个工作就进行不下去了，需要逐一去排查到底是哪个环节出错了，耗时久且效率低。
Linux-进程间通信
AI_ELF的博客
08-23 6346
数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
Linux信号量 | 进程间通信—信号量——详解
weixin_45596153的博客
04-06 362
目录 一.信号量的概念 二.信号量的使用 三.信号量的具体应用 四.总结 一.信号量的概念 1.信号量的定义 为了防止出现因多个程序同时访问临界资源而引发的一系列问题，我们需要一种方法，它可以...
Linux 进程间通信
冰果滴的博客
11-12 1263
因为进程是具有独立性的，所以进程间想交互数据，成本会非常高，因此需要多进程进行协同处理一件事情，就有了进程间通信。要注意，虽然进程独立了，但不是彻底独立了，有时候，需要双方能够进行一定程度的信息交互。
linux下c语言编程4-使用共享内存实现进程间通信.pdf
11-01
。。。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值