linux c 进程间通信

最新推荐文章于 2024-05-08 19:04:25 发布
最新推荐文章于 2024-05-08 19:04:25 发布
阅读量1.2k 收藏 9
点赞数 1
原文链接：https://blog.csdn.net/whatday/article/details/99304973
版权

进程间通信概述

进程间通信（InterProcess Communication，IPC）是指在不同进程之间传播或交换信息。

Linux的进程间通信方法有管道(Pipe)和有名管道(FIFO)、信号(Signal)、消息队列(Message Queue)、共享内存(Shared Memory)、信号量(Semaphore)、套接字(Socket)等。

Linux进程间通信由以下几部分发展而来：

1、UNIX进程间通信 

2、基于System V 进程间通信 

3、POSIX进程间通信

POSIX进程间通信是最新的技术，POSIX表示可移植操作系统接口。

 

管道和有名管道

管道是半双工的（即数据单向流动，先进先出），有固定的读端和写端。数据被一个进程读出后，将被从管道删除，其他进程将不能再读到这些数据。

管道提供了简单的流控制机制，进程试图读空管道时，进程将阻塞。同样，管道已经满时，进程再试图向管道写入数据，进程将阻塞。

管道包括无名管道(Pipe)和有名管道(FIFO)两种。无名管道用于父进程和子进程间的通信，有名管道可用于运行于同一系统中的任意两个进程间的通信。

 

无名管道

函数用法

#include<unistd.h>

int pipe(int fd[2]);

函数功能

创建无名管道

fd：文件描述符，fd[0]用于读管道，fd[1]用于写管道

函数返回值成功返回 0 ， 失败返回 -1 并产生errno

       当一个无名管道(Pipe)建立时，它会创建两个文件描述符：fd[0]用于读管道，fd[1]用于写管道。                      

要关闭管道只需要关闭这两个文件描述符即可。

管道用于不同进程间通信。通常先创建一个管道，再通过fork函数创建一个子进程，该子进程会继承父进程所创建的管道。必须在系统调用fork( )前调用pipe( )，否则子进程将不会继承文件描述符。

实例：使用管道实现数据的发送与接收

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
 
void ReadPipe(int fd)//读管道
{
	int ret;
	char buf[32] = {0};
	
	while(1)
	{
		ret = read(fd, buf, sizeof(buf));
		if (-1 == ret)
		{
			perror("read");
			exit(1);
		}
		if (!strcmp(buf, "bye"))
		{
			break;
		}
		printf("read from pipe: %s\n", buf);
		memset(buf, 0, sizeof(buf));
	}
	close(fd);
}
 
void WritePipe(int fd)//写管道
{
	int ret;
	char buf[32] = {0};
 
	while (1)
	{
		scanf("%s", buf);
		ret = write(fd, buf, strlen(buf));
		if (-1 == ret)
		{
			perror("write");
			exit(1);
		}
		if (!strcmp(buf, "bye"))
		{
			break;
		}
		memset(buf, 0, sizeof(buf));
	}
	close(fd);
}
 
int main()
{
	int fd[2];
	int ret;
	pid_t pid;
 
	ret = pipe(fd);	//创建管道
	if (-1 == ret)
	{
		perror("pipe");
		exit(1);
	}
 
	pid = fork();  //创建进程
	if (-1 == pid)
	{
		perror("fork");
		exit(1);
	}
	else if (0 == pid)
	{
		close(fd[1]);		//关闭写端口
		ReadPipe(fd[0]);	//fd[0]读数据
	}
	else
	{
		close(fd[0]);		//关闭读端口
		WritePipe(fd[1]);	//fd[1]写数据
 
		int status;
		wait(&status);
	}
	return 0;
}

 

有名管道

函数用法

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

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

函数功能

创建有名管道

pathname：文件名

mode：设定创建的文件的权限

函数返回值成功返回 0 ， 失败返回 -1 并产生errno

        命名管道(FIFO)与无名管道的区别在于它提供一个路径与之关联，以FIFO的文件形式存储于文件系统中。命名管道是一个设备文件。因此，即使进程与创建FIFO的进程不存在亲缘关系，只要可以访问该路径，就能够通过FIFO相互通信。实例：使用有名管道，实现一个终端发送数据，一个终端接收数据

fifo_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()
{
	char buf[32] = {0};
	int fd;
	int ret;
 
	fd= mkfifo("fifo.tmp", S_IRWXU);//创建有名管道
	if (-1 == fd)
	{
		perror("mkfifo");
		exit(1);
	}
 
	fd = open("fifo.tmp", O_RDONLY);//只读方式打开文件fifo.tmp
	if (-1 == fd)
	{
		perror("open");
		exit(1);
	}
 
	while(1)
	{
		ret = read(fd, buf, sizeof(buf));//从文件中读取数据
		if (-1 == ret)
		{
			perror("read");
			exit(1);
		}
 
		if (!strcmp(buf, "bye"))//读取到bye结束循环
		{
			break;
		}
		
		printf("read:%s\n", buf);
		memset(buf, 0, sizeof(buf));
	}
 
	close(fd);
	unlink("fifo.tmp");//在管道使用结束后删除文件fifo.tmp
	return 0;
}

 fifo_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;
	int ret;
	char buf[32] = {0};
 
	fd = open("fifo.tmp", O_WRONLY);//以只写方式打开文件fifo.tmp
	while (1)
	{
		scanf("%s", buf);
 
		ret = write(fd, buf, strlen(buf));//写入数据到文件
		if (-1 == ret)
		{
			perror("write");
			exit(1);
		}
 
		if (!strcmp(buf, "bye"))//输入bye结束写入
		{
			break;
		}
		memset(buf, 0, sizeof(buf));
	}
 
	close(fd);
	return 0;
}

注：在运行测试时候必须先运行创建了管道的程序，本文中要先运行fifo_read.c

 

信号

信号(signal)机制是Unix系统中最为古老的进程间通信机制，很多条件可以产生一个信号：

（1）当用户按某些按键时，产生信号。

（2）硬件异常产生信号：除数为0、无效的存储访问等等。这些情况通常由硬件检测到，将其通知内核，然后内核产生适当的信号通知进程，例如，内核对正访问一个无效存储区的进程产生一个SIGSEGV信号 。

（3）进程用kill函数将信号发送给另一个进程。

（4）用户可用kill命令将信号发送给其他进程。

 

当某信号出现时，将按照下列三种方式中的一种进行处理：

（1）忽略此信号，大多数信号都按照这种方式进行处理，但有两种信号决不能被忽略,它们是： SIGKILL\SIGSTOP。 这是因为这两种信号向超级用户提供了一种终止或停止进程的方法。

（2）执行系统默认动作，对大多数信号的系统默认动作是终止该进程。

（3）执行用户希望的动作，通知内核在某种信号发生时，调用一个用户函数。在用户函数中，执行用户希望的处理。

 

在终端中输入 kill -l 可以查看到系统设定的信号的宏定义。

发送信号的函数有：kill(向任意进程发送信号)、raise(只能向当前进程发送信号)、abort(发送SIGABRT信号，可以让进程异常终止)、alarm(发送SIGALRM闹钟信号)

 

实例：实现0-59的计时，计时到60时变为0.

使用alarm函数可以设置一个时间值(闹钟时间)，当所设置的时间到了时，产生SIGALRM信号。然后使用signal函数捕捉SIGALRM信号，并且自定义信号处理方式。

#include<stdio.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
int t;
 
void print()
{
	system("clear");//清屏
	alarm(1);//1秒后给当前进程发送一个SIGALRM信号，一直在执行
	printf("%d\n", (t++)%60);
 
}
 
int main()
{
	system("clear");//清屏
	alarm(1);//1秒后给当前进程发送一个SIGALRM信号，只执行一次
	signal(SIGALRM, print);
 
	while (1);//必须有，不然进程就直接结束了
 
	return 0;
}

 

消息队列

消息队列(Message Queue)，就是一个消息的链表，是一系列保存在内核中消息的列表。用户进程可以向消息队列添加消息，也可以向消息队列读取消息。

消息队列与管道通信相比，其优势是对每个消息指定特定的消息类型，接收的时候不需要按照队列次序，而是可以根据自定义条件接收特定类型的消息。

上图中进程A指定了类型1，进程C指定了类型2，，进程B指定了类型1。按上图演示，最后进程B会接收到进程A发送的hello，进程C的world接收不到，因为B和C不在同一类型。

实例：使用消息队列和fork，实现两个终端的收发数据，既能收，又能发。

msg_send.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
 
#define MSGKEY 1234
 
struct msgbuf
{
	long mtype;     /* message type, must be > 0 */
	char mtext[100];  /* message data */
};
 
 
int main()
{
	int msgid;
	int ret;
	struct msgbuf mbuf;
	pid_t pid;
 
	msgid = msgget(MSGKEY, IPC_CREAT | IPC_EXCL);	//创建消息队列
	if (-1 == msgid)
	{
		perror("msgget");
		exit(1);
	}
 
	pid = fork();
	if (-1 == pid)
	{
		perror("fork");
		exit(1);
	}
	else if (0 == pid)		//子进程发送数据
	{
		while (1)
		{
			memset(mbuf.mtext, 0, sizeof(mbuf.mtext));
			scanf("%s", mbuf.mtext);
			mbuf.mtype = 1;
 
			ret = msgsnd(msgid, &mbuf, sizeof(mbuf.mtext), 0);
			if (-1 == ret)
			{
				perror("msgsnd");
				exit(1);
			}
 
			if (!strcmp(mbuf.mtext, "bye"))
			{
				mbuf.mtype = 2;
				msgsnd(msgid, &mbuf, sizeof(mbuf.mtext), 0);
				break;
			}
		}
	}
	else		//父进程接收数据
	{
		while (1)
		{
			memset(mbuf.mtext, 0, sizeof(mbuf.mtext));
 
			ret = msgrcv(msgid, &mbuf, sizeof(mbuf.mtext), 2,0);
			if (-1 == ret)
			{
				perror("msgrcv");
				exit(1);
			}
 
			if (!strcmp(mbuf.mtext, "bye"))
			{
				kill(pid, 2);
				break;
			}
			printf("\t%s\n", mbuf.mtext);
		}
	}
	sleep(1);
	msgctl(msgid, IPC_RMID, NULL);//销毁消息队列
	return 0;
}
 msg_write.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
 
#define MSGKEY 1234
 
struct msgbuf
{
	long mtype;     /* message type, must be > 0 */
	char mtext[100];  /* message data */
};
 
 
int main()
{
	int msgid;
	int ret;
	struct msgbuf mbuf;
	pid_t pid;
 
	msgid = msgget(MSGKEY, 0);	//打开消息队列
	if (-1 == msgid)
	{
		perror("msgget");
		exit(1);
	}
 
	pid = fork();
	if (-1 == pid)
	{
		perror("fork");
		exit(1);
	}
	else if (0 == pid)		//子进程发送数据
	{
		while (1)
		{
			memset(mbuf.mtext, 0, sizeof(mbuf.mtext));
			scanf("%s", mbuf.mtext);
			mbuf.mtype = 2;
 
			ret = msgsnd(msgid, &mbuf, sizeof(mbuf.mtext), 0);
			if (-1 == ret)
			{
				perror("msgsnd");
				exit(1);
			}
 
			if (!strcmp(mbuf.mtext, "bye"))
			{
				mbuf.mtype = 1;
				msgsnd(msgid, &mbuf, sizeof(mbuf.mtext), 0);
 
				break;
			}
		}
	}
	else		//父进程接收数据
	{
		while (1)
		{
			memset(mbuf.mtext, 0, sizeof(mbuf.mtext));
			ret = msgrcv(msgid, &mbuf, sizeof(mbuf.mtext), 1,0);
			if (-1 == ret)
			{
				perror("msgrcv");
				exit(1);
			}
 
			if (!strcmp(mbuf.mtext, "bye"))
			{
				kill(pid, 2);
				break;
			}
			printf("\t%s\n", mbuf.mtext);
		}
	}
	return 0;
}

 注：测试程序时先启动创建了消息队列的程序，本文中应该是先启动msg_send.c

 

共享内存

共享内存允许一个或多个进程共享一个给定的物理存储区，这一个给定的物理存储区可以被两个或两个以上的进程映射至自身的地址空间中。

采用共享内存进行通信的一个主要好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝，对于像管道和消息队里等通信方式，则需要在内核和用户空间进行四次的数据拷贝，而共享内存则只拷贝两次：一次从输入文件到共享内存区，另一次从共享内存到输出文件。

使用共享内存的步骤：

（1）申请共享内存   shmget

（2）映射                  shmat

（3）使用

（4）解除映射           shmdt

（5）销毁共享内存    shmctl

实例：

shm.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
 
#define SHMKEY 1234
#define SHMSIZE 4096
 
int main()
{
	int shmid;
	void *shmaddr;
	int count = 0;
 
	shmid = shmget(SHMKEY, SHMSIZE, 0666|IPC_CREAT);//创建共享内存
	if (-1 == shmid)
	{
		perror("shmget");
		exit(1);
	}
 
	shmaddr = shmat(shmid, NULL, 0);//映射到虚拟地址空间
	if (-1 == shmaddr)
	{
		perror("shmat");
		exit(1);
	}
 
	*(int *)shmaddr = count;//把数据写到内存
 
	while(1)
	{
		count = *(int *)shmaddr;//从内存读数据
		//usleep(100000);
 
		if (count > 100)
		{
			break;
		}
 
		printf("A:%d\n", count);
		count++;
 
		*(int *)shmaddr = count;//数据写回内存
 
		usleep(100000);
	}
 
	shmdt(shmid);		//解除映射
	shmctl(shmid, IPC_RMID, NULL);//销毁映射
	return 0;
}

 shm2.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
 
#define SHMKEY 1234
#define SHMSIZE 4096
 
int main()
{
	int shmid;
	void *shmaddr;
	int count = 0;
 
	shmid = shmget(SHMKEY, SHMSIZE, 0);//获取共享内存
	if (-1 == shmid)
	{
		perror("shmget");
		exit(1);
	}
 
	shmaddr = shmat(shmid, NULL, 0);//映射到虚拟地址空间
	if (-1 == shmaddr)
	{
		perror("shmat");
		exit(1);
	}
 
	while(1)
	{
		count = *(int *)shmaddr;//从内存读数据
		//usleep(100000);
 
		if (count > 100)
		{
			break;
		}
 
		printf("B:%d\n", count);
		count++;
 
		*(int *)shmaddr = count;//把数据写回共享内存
 
		usleep(100000);
	}
 
	return 0;
}

注：在测试时，应该先启动创建了共享内存的那个程序，也就是先启动shm.c。

测试现象是只启动了shm.c时数字刷新步长为1 (也就是 1 2 3 4 5 这样变)，在shm.c运行时启动了shm2.c后，数字刷新步长为2 (也就是 1 3 5 7 这样变)

思考：如果将例子里的 延时usleep(100000);  挪到从内存读数据后面（也就是注释掉的那串代码）会发生什么现象？过程是怎么样子的？怎么解决？(解决方案见信号量实例)

 

信号量

信号量(Semaphore)，又名信号灯，主要用途是保护临界资源。进程可以根据它来判定是否能够访问某些共享资源。除了用于访问控制外，还可用于进程同步。

二值信号灯：信号灯的值只能取0或1，类似于互斥锁。 但两者有不同：                  

                     信号灯强调共享资源，只要共享资源可用，其他进程同样可以修改信号灯的值；

                     互斥锁更强调进程，占用资源的进程使用完资源后，必须由进程本身来解锁。

计数信号灯：信号灯的值可以取任意非负值。

使用信号量的步骤

（1）创建(获取) 信号量         semget

（2）初始化信号量                semctl

（3）使用(P操作/V操作)        semop（4）销毁信号量                    semctl

实例：共享内存的例子的思考的解决方案。

sem.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/sem.h>
 
 
#define SHMKEY 1234
#define SHMSIZE 4096
#define SEMKEY 1234
 
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 sem_p(int semid)
{
	int ret;
	struct sembuf sbuf;
 
	sbuf.sem_num = 0;//第一个
	sbuf.sem_op = -1;//P操作
	sbuf.sem_flg = SEM_UNDO;//SEM_UNDO进程异常自动UNDO
 
	ret = semop(semid, &sbuf, 1);
	if (ret == -1)
	{
		perror("semop");
		return;
	}
}
void sem_v(int semid)
{
	int ret;
	struct sembuf sbuf;
 
	sbuf.sem_num = 0;//第一个
	sbuf.sem_op = 1;//V操作
	sbuf.sem_flg = SEM_UNDO;//SEM_UNDO进程异常自动UNDO
 
	ret = semop(semid, &sbuf, 1);
	if (ret == -1)
	{
		perror("semop");
		return;
	}
}
 
int main()
{
	int shmid;
	void *shmaddr;
	int count = 0;
	int semid;
	union semun unsem;
 
	semid = semget(SEMKEY, 1, IPC_CREAT | IPC_EXCL);	//创建信号量
	if (-1 == semid)
	{
		perror("semget");
		exit(1);
	}
 
	unsem.val = 1;//初始化成二值信号量
	semctl(semid, 0, SETVAL, unsem);//初始化信号量
 
	shmid = shmget(SHMKEY, SHMSIZE, IPC_CREAT | IPC_EXCL);//创建共享内存
	if (-1 == shmid)
	{
		perror("shmget");
		exit(1);
	}
 
	shmaddr = shmat(shmid, NULL, 0);//映射到虚拟地址空间
	if (NULL == shmaddr)
	{
		perror("shmat");
		exit(1);
	}
 
	*(int *)shmaddr = count;//把数据写到内存
 
	while(1)
	{
		sem_p(semid);//P操作
 
		count = *(int *)shmaddr;//从内存读数据
		usleep(100000);
 
		if (count > 100)
		{
			break;
		}
 
		printf("A:%d\n", count);
		count++;
 
		*(int *)shmaddr = count;//数据写回内存
 
		//usleep(100000);
 
		sem_v(semid);//V操作
	}
 
	shmdt(shmaddr);		//解除映射
 
	sleep(1);
	shmctl(shmid, IPC_RMID, NULL);//销毁映射
 
	semctl(semid, 0, IPC_RMID);//销毁信号量
	return 0;
}

sem2.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/sem.h>
 
 
#define SHMKEY 1234
#define SHMSIZE 4096
#define SEMKEY 1234
 
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 sem_p(int semid)
{
	int ret;
	struct sembuf sbuf;
 
	sbuf.sem_num = 0;//第一个
	sbuf.sem_op = -1;//P操作
	sbuf.sem_flg = SEM_UNDO;//SEM_UNDO进程异常自动UNDO
 
	ret = semop(semid, &sbuf, 1);
	if (ret == -1)
	{
		perror("semop_p");
		return;
	}
}
void sem_v(int semid)
{
	int ret;
	struct sembuf sbuf;
 
	sbuf.sem_num = 0;//第一个
	sbuf.sem_op = 1;//V操作
	sbuf.sem_flg = SEM_UNDO;//SEM_UNDO进程异常自动UNDO
 
	ret = semop(semid, &sbuf, 1);
	if (ret == -1)
	{
		perror("semop_v");
		return;
	}
}
 
int main()
{
	int shmid;
	void *shmaddr;
	int count = 0;
	int semid;
	union semun unsem;
 
	semid = semget(SEMKEY, 1, 0);	//获取信号量
	if (-1 == semid)
	{
		perror("semget");
		exit(1);
	}
 
	//unsem.val = 1;
	//semctl(semid, 0, SETVAL, unsem);//初始化信号量
 
	shmid = shmget(SHMKEY, SHMSIZE, 0);//获取共享内存
	if (-1 == shmid)
	{
		perror("shmget");
		exit(1);
	}
 
	shmaddr = shmat(shmid, NULL, 0);//映射到虚拟地址空间
	if (NULL == shmaddr)
	{
		perror("shmat");
		exit(1);
	}
 
	while(1)
	{
		sem_p(semid);//P操作
 
		count = *(int *)shmaddr;//从内存读数据
		usleep(100000);
 
		if (count > 100)
		{
			break;
		}
 
		printf("B:%d\n", count);
		count++;
 
		*(int *)shmaddr = count;//数据写回内存
 
		//usleep(100000);
 
		sem_v(semid);//V操作
	}
 
	shmdt(shmaddr);		//解除映射
	return 0;
}

 

 

 

whatday
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
LinuxC—进程通信
wait2023的博客
01-30 1293
定义匿名管道用来实现具有亲缘关系的进程之间的通信，匿名管道是由内核创建的一块内存区域，返回这块区域对应的文件描述符后，进程间可以通过这个文件描述符的操作来进行通信。特点相关函数1024。
linux进程间通信
qq_54626677的博客
02-13 143
进程是具有独立性的，我们想要通信 — 通信的成本一定不低。你需要先让不同的进程看到同一份资源通信数据传输：一个进程需要将它的数据发送给另一个进程。资源共享：多个进程之间共享同样的资源。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。管道是Unix中最古老的进程间通信的形式。
Linux进程间通信(Linux IPC)
Peerless__的博客
06-04 6446
在Linux下由很多种进程间通信的方式，在下面主要介绍七种，分别是：匿名管道(PIPE)、命名管道(FIFO)、信号、共享内存映射、共享内存、消息队列、信号量、UNIX域套接字。
2024年最新鸿蒙来啦！快速入门OpenHarmony的LiteOS微内核，你不看看吗？，2024年最新面试官打击你怎么办
最新发布
2401_84871470的博客
05-08 1149
tools | 构建工具及相关配置和代码。
C++共享内存相关的秘密
霍迪迪的博客
08-19 441
得到一个共享内存标识符或创建一个共享内存对象 ，也就是该即可创建一个共享内存，也可以获取一个共享内存，key是开发者定义的一个整数（标识符），如果该标识符在内存池已经存在，则是获取该段内存的地址，否则是开辟内存空间，创建共享内存。共享内存进行并发访问时使用，用于对信号量进行操作来实现进程之间的互斥和同步。该函数定义在头文件 sys/sem.h中操作一个或一组信号。：把共享内存区对象映射到调用进程的地址空间，一般在创建共享内存之后。：成功：附加好的共享内存地址，失败：-1，错误原因存于errno中。
【C/C++】【Linux】Linux系统调用——进程间通信
乞木的博客
08-19 7527
Linux系统调用——进程间通信 进程间通信概述 进程间通信（InterProcess Communication，IPC）是指在不同进程之间传播或交换信息。 Linux的进程间通信方法有管道(Pipe)和有名管道(FIFO)、信号(Signal)、消息队列(Message Queue)、共享内存(Shared Memory)、信号量(Semaphore)、套接字(Socket)等。 Li...
C++ 使用共享内存的进程通信方式模拟生产者消费者模型
hanxiaoyong_的博客
04-16 392
C++ 使用共享内存的进程通信方式模拟生产者消费者模型，进程间的同步使用信号量SystemV方式。
linux下进程间通信
文武天下
07-08 638
共享内存 两个或更多进程访问同一块内存
linux c 进程间通信 消息队列
03-01
在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是...以上就是关于“Linux C 进程间通信 消息队列”的详细介绍，通过理解和实践，你将能够熟练地在C语言环境中运用消息队列进行进程间的有效通信。
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
linux c 进程间通信 信号灯 程序源码
03-01
本文将详细讲解Linux C编程中的一种进程间通信方式——信号灯（Semaphore），并结合提供的程序源码进行解析。 信号灯是同步原语之一，它允许进程在执行过程中对某些资源进行互斥访问或同步操作。信号灯由两个基本...
linux c 进程间通信(共享内存+消息队列)
07-28
在Linux操作系统中，C语言是实现底层系统编程的常用工具，尤其在进程间通信（IPC，Inter-Process Communication）方面。本主题将深入探讨两种主要的IPC机制：共享内存和消息队列。 **共享内存**是Linux进程间通信的...
Linux进程间通信--使用信号
09-15
Linux进程间通信是一种让不同进程之间交换信息或协调工作的方式，而在Linux系统中，信号（Signal）是一种简单但重要的通信机制。本文将深入探讨如何利用信号进行进程间通信。 首先，信号是操作系统用来通知进程发生...
Linux C编程之进程间通信
qq_53003541的博客
08-06 1024
linux进程通信
LinuxC 进程之间通信
qq_53580962的博客
09-19 325
Linux C进程之间通信
【嵌入式】Linux C编程——进程间通信方式
a_qwq_a的博客
06-05 293
对进程间通信的总结
LinuxC：进程间通信
weixin_48874444的博客
06-04 107
内核提供，半双工，自同步机制。命名管道（有名管道）
【C++服务器入门基础------7.IPC进程间通信--信号量】
qq_39583373的博客
02-26 935
c++服务器入门系列 大学生寒假在家里过于无聊，整理一下以前学过的知识，顺便复习一下，水平较低，专业性不强，仅供参考。
进程间通信之systemV信号量（semget semop semctl相关操作）
jane_yao的博客
08-30 772
一、什么是信号量？ 信号量的本质就是计数器，记录临界资源的数目，用来协助进程同步互斥的访问临界资源。为什么不在进程中定义一个全局变量作为计数器呢？两个进程间的地址空间是各自独立的，各自有各自的虚拟内存空间。多进程之间不能看到各自进程中的全局变量。（进程间的虚拟内存https://blog.csdn.net/jane_yao/article/details/81635979）既然多个进程都能对信号...
Linux编程实战：进程间通信探索
通过这个实验，学生不仅能够巩固C语言编程技能，还能够加深对Linux操作系统内部工作原理的理解，特别是进程间通信模块。这对于理解分布式系统、网络编程以及系统编程至关重要。此外，实验过程中可能会遇到的问题解决...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值