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

最新推荐文章于 2024-05-11 15:24:08 发布

文曲尽墨琛乃缺

最新推荐文章于 2024-05-11 15:24:08 发布

阅读量354

点赞数

分类专栏： linux嵌入式系统 C语言文章标签： Linux系统进程间通信

本文链接：https://blog.csdn.net/qq_42519524/article/details/99697784

版权

C语言同时被 2 个专栏收录

26 篇文章 2 订阅

订阅专栏

linux嵌入式系统

10 篇文章 1 订阅

订阅专栏

进程间通信概述

1.数据传输
一个进程需要将它的数据发送给另一个进程
2.资源共享
多个进程之间共享同样的资源
3.通知事件
一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事件
4.进程控制
有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有操作，并能够及时知道它的状态改变

现在Linux使用的进程间通信方式包括：
1、管道（pipe）和有名管道（FIFO）
2、信号（signal）
3、消息队列
4、共享内存
5、信号量
6、套接字（socket）

管道通讯

管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。
一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据
数据被一个进程读出后，将被从管道中删除，其它读进程将不能再读到这些数据。
管道提供了简单的流控制机制，进程试图读空管道时，进程将阻塞。同样，管道已经满时，进程再试图向管道写入数据，进程将阻塞

管道包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者可用于运行于同一系统中的任意两个进程间的通信。
命名管道和无名管道基本相同，但也有不同点：无名管道只能由父子进程使用；但是通过命名管道，不相关的进程也能交换数据。

无名管道创建：
int pipe(int filedis[2])；
当一个管道建立时，它会创建两个文件描述符：
filedis[0] 用于读管道，
filedis[1] 用于写管道
在这里插入图片描述

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

int main()
{
	int num = 0;
	int fd[2] = {0};
	int ret = pipe(fd);   //创建无名管道
	if (-1 == ret)
	{
		perror("pipe");
		exit(1);
	}

	pid_t pid = fork();
	if (-1 == pid)
	{
		perror("fork");
		exit(1);
	}
	else if (0 == pid)   //子进程
	{
		num++;
		printf("child num = %d\n", num);

		ret = write(fd[1], &num, sizeof(int));  //写管道
		if (-1 == ret)
		{
			perror("write");
		}
	}
	else    //父进程
	{
		ret = read(fd[0], &num, sizeof(num));   //读管道   如果管道是空，阻塞
		if (-1 == ret)
		{
			perror("read");
		}

		num++;
		printf("parent num = %d\n", num);

		int status;
		wait(&status);
	}

	return 0;
}

注意事项：必须在系统调用fork( )前调用pipe( )，否则子进程将不会继承文件描述符

命名管道

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

int main()
{
	int ret = mkfifo("fifo.tmp", O_CREAT | O_EXCL);	   //创建有名管道
	if (-1 == ret)
	{
		perror("mkfifo");
		exit(1);
	}

	int fd = open("fifo.tmp", O_WRONLY);
	if (-1 == fd)
	{
		perror("open");
		exit(1);
	}

	char buf[32] = {0};
	while (1)
	{
		scanf("%s", buf);

		ret = write(fd, buf, strlen(buf));
		if (-1 == ret)
		{
			perror("write");
		}

		if (!strcmp(buf, "bye"))
		{
			break;
		}

		memset(buf, 0, sizeof(buf));
	}

	unlink("fifo.tmp");           //删除文件

	return 0;
}

表头文件: #include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char * pathname, mode_t mode)
pathname：FIFO文件名
mode：属性（见文件操作章节）
一旦创建了一个FIFO，就可用open打开它，一般的文件访问函数（close、read、write等）都可用于FIFO

信号通讯

信号(signal)机制是Unix系统中最为古老的进程间通信机制，很多条件可以产生一个信号：
1、当用户按某些按键时，产生信号
2、硬件异常产生信号：除数为0、无效的存储访问等等。这些情况通常由硬件检测到，将其通知内核，然后内核产生适当的信号通知进程，例如，内核对正访问一个无效存储区的进程产生一个SIGSEGV信号
3、进程用kill函数将信号发送给另一个进程
4、用户可用kill命令将信号发送给其他进程
当某信号出现时，将按照下列三种方式中
的一种进行处理：
1、忽略此信号
大多数信号都按照这种方式进行处理，但有两种信号
决不能被忽略,它们是：
SIGKILL\SIGSTOP。
这两种信号不能被忽略的原因是：
它们向超级用户提供了一种终止或停止进程的方法
2、执行用户希望的动作
通知内核在某种信号发生时，调用一个用户函数。在用户函数中，执行用户希望的处理
3、执行系统默认动作
对大多数信号的系统默认动作是终止该进程

发送信号的主要函数有 kill和raise。
区别：
Kill既可以向自身发送信号，也可以向其他进程发送信号。与kill函数不同的是，raise函数是向进程自身发送信号
#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig)
int raise(int sig)
kill的pid参数有四种不同的情况：
1、pid>0
将信号发送给进程ID为pid的进程。
2、pid =0
将信号发送给同组的进程。
3、pid < 0
将信号发送给其进程组ID等于pid绝对值的进程。
4、pid =－1
将信号发送给所有进程。
sig全称signall（信号）
输入信号的名字或者代表数子字符

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

int main(int argc, char *argv[])
{
	//kill(atoi(argv[1]), 9);
	kill(atoi(argv[1]), SIGKILL);  //给指定进程发送指定的信号

	raise(9);   //给自己发送信号

	while (1);

	return 0;
}


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

void print(int sig)
{
	printf("this is %d\n", sig);
}

void handler(int sig)
{
	printf("this is %d\n", sig);
	alarm(2);
}

pause函数使调用进程挂起直至捕捉到一个信号。
#include <unistd.h>
int pause(void)
只有执行了一个信号处理函数后，挂起才结束

当系统捕捉到某个信号时，可以忽略该信号或是使用指定的处理函数来处理该信号，或者使用系统默认的方式
信号处理的主要方法有两种：
一种是使用简单的signal函数，另一种是使用信号集函数组
————————————————
版权声明：本文为CSDN博主「文曲尽墨琛乃缺」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_42519524/article/details/99654941
int main()
{
//signal(2, SIG_IGN);
signal(SIGINT, SIG_IGN); //如果进程收到SIGINT信号，则忽略
signal(SIGKILL, SIG_IGN); //不能忽略

	signal(SIGHUP, print);

	signal(SIGALRM, handler);

	alarm(2);     //2秒钟之后，给进程发送SIGALRM信号  有效期一次

	while (1);

	return 0;
}

#include <signal.h>
signal(int signum, sighandler_t handler))
handler：
SIG_IGN：忽略此信号
SIG_DFL: 按系统默认方式处理

每个进程只能有一个闹钟时间.如果在调用alarm时，以前已为该进程设置过闹钟时间，而且它还没有超时，以前登记的闹钟时间则被新值代换
如果有以前登记的尚未超过的闹钟时间，而这次seconds值是0，则表示取消以前的闹钟
————————————————
版权声明：本文为CSDN博主「文曲尽墨琛乃缺」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_42519524/article/details/99654941

消息队列

消息队列就是一个消息的链表.可以把消息看作一个记录，具有特定的格式.进程可以向中按照一定的规则添加新消息;另一些进程则可以从消息队列中读走消息
目前主要有两种类型的消息队列：
POSIX消息队列以及系统V消息队列，系统V消息队列目前被大量使用
系统V消息队列是随内核持续的，只有在内核重起或者人工删除时，该消息队列才会被删除
消息队列的内核持续性要求每个消息队列都在系统范围内对应唯一的键值，所以，要获得一个消息队列的描述字，必须提供该消息队列的键值
在这里插入图片描述
创建并打开消息队列
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgget(key_t key, int msgflg)
key：键值，由ftok获得。
msgflg：标志位。
IPC_CREAT
创建新的消息队列
IPC_EXCL
与IPC_CREAT一同使用，表示如果要创建的消息队列已经存在，则返回错误。
IPC_NOWAIT
读写消息队列要求无法得到满足时，不阻塞
返回值：与健值key相对应的消息队列描述字
struct msgbuf
{
long mtype；/消息类型/
char mtext[1]; /消息数据的首地址/
}

在以下两种情况下，将创建一个新的消息队列：
1、如果没有与健值key相对应的消息队列，并且 msgflg中包含了IPC_CREAT标志位。
2、key参数为IPC_PRIVATE

发送消息
表头文件：#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgsnd(int msqid,struct msgbuf*msgp,int msgsz,int msgflg)
参数：
Msqid: 已打开的消息队列id
Msgp: 存放消息的结构体
Msgsz: 消息数据长度
Msgflg: 发送标志，有意义的msgflg标志为IPC_NOWAIT，指明在消息队列没有足够空间容纳要发送的消息时，msgsnd是否等待

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

#define MSGKEY     1000  //键值（任意）

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

int main()
{
	//创建消息队列
	int msgid = msgget(MSGKEY, IPC_CREAT | IPC_EXCL);   //键值（唯一）   创建并且不能存在
	if (-1 == msgid)
	{
		perror("msgget");
		exit(1);
	}

	struct msgbuf m;
	int ret;
	
	while (1)
	{
		memset(&m, 0, sizeof(struct msgbuf));
		scanf("%s", m.mtext);
		m.mtype = 1;

		ret = msgsnd(msgid, &m, sizeof(m.mtext), 0);
		if (-1 == ret)
		{
			perror("msgsnd");
		}

		if (!strcmp(m.mtext, "bye"))
		{
			break;
		}
	}

	msgctl(msgid, IPC_RMID, NULL);
	return 0;
}

接受消息
表头文件：#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgrcv(int msqid, struct msgbuf *msgp, int msgsz, long msgtyp, int msgflg)
功能：
从msqid代表的消息队列中读取一个msgtyp类型的消息，并把消息存储在msgp指向的msgbuf结构中。在成功地读取了一条消息以后，队列中的这条消息将被删除

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

#define MSGKEY     1000

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

int main()
{
	//获取消息队列
	int msgid = msgget(MSGKEY, 0);   //键值（唯一）
	if (-1 == msgid)
	{
		perror("msgget");
		exit(1);
	}

	struct msgbuf m;
	int ret;
	
	while (1)
	{
		memset(&m, 0, sizeof(struct msgbuf));

		ret = msgrcv(msgid, &m, sizeof(m.mtext), 1, 0);   //1表示接收的类型
		if (-1 == ret)
		{
			perror("msgsnd");
		}

		if (!strcmp(m.mtext, "bye"))
		{
			break;
		}

		printf("%s\n", m.mtext);
	}

	return 0;

如果要发相互发送的话，就必须把一个发送，一个接受化为一种消息类型，long mtype =1；
另一个发过来，这个接受又为另一种类型long mtype =2等等。这也称为多进程消息队列。 eg：
一号机：

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

#define MSGKEY     1000

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

void SendData(int msgid)
{
	struct msgbuf m;
	int ret;

	while (1)
	{
		memset(&m, 0, sizeof(struct msgbuf));
		scanf("%s", m.mtext);
		m.mtype = 1;

		ret = msgsnd(msgid, &m, sizeof(m.mtext), 0);
		if (-1 == ret)
		{
			perror("msgsnd");
		}

		if (!strcmp(m.mtext, "bye"))
		{
			m.mtype = 2;
			msgsnd(msgid, &m, sizeof(m.mtext), 0);   //通知父进程结束
			break;
		}
	}
}

void RecvData(int msgid, int pid)   //父进程
{
	struct msgbuf m;
	int ret;

	while (1)
	{
		ret = msgrcv(msgid, &m, sizeof(m.mtext), 2, 0);
		if (-1 == ret)
		{
			perror("msgrcv");
		}

		if (!strcmp(m.mtext, "bye"))
		{	
			kill(pid, SIGINT);
			break;
		}

		printf("\t\t%s\n", m.mtext);

		memset(&m, 0, sizeof(m));
	}
}

int main()
{
	//创建消息队列
	int msgid = msgget(MSGKEY, IPC_CREAT | IPC_EXCL);   //键值（唯一）   创建并且不能存在
	if (-1 == msgid)
	{
		perror("msgget");
		exit(1);
	}

	int ret;

	pid_t pid = fork();
	if (-1 == pid)
	{
		perror("fork");
		exit(1);
	}
	else if (0 == pid)     //子进程
	{
		SendData(msgid);
	}
	else
	{
		RecvData(msgid, pid);

		int status;
		wait(&status);
	}
	
	msgctl(msgid, IPC_RMID, NULL);

	return 0;
}

2号机：

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

#define MSGKEY     1000

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

void RecvData(int msgid, int pid)
{
	int ret;
	struct msgbuf m;

	while (1)
	{
		memset(&m, 0, sizeof(struct msgbuf));

		ret = msgrcv(msgid, &m, sizeof(m.mtext), 1, 0);   //1表示接收的类型
		if (-1 == ret)
		{
			perror("msgsnd");
		}

		if (!strcmp(m.mtext, "bye"))
		{
			kill(pid, SIGINT);    //结束子进程
			break;
		}

		printf("\t\t%s\n", m.mtext);
	}
}

void SendData(int msgid)
{
	struct msgbuf m;
	int ret;

	while (1)
	{
		memset(&m, 0, sizeof(struct msgbuf));
		scanf("%s", m.mtext);
		m.mtype = 2;

		ret = msgsnd(msgid, &m, sizeof(m.mtext), 0);
		if (-1 == ret)
		{
			perror("msgsnd");
		}

		if (!strcmp(m.mtext, "bye"))
		{
			m.mtype = 1;
			msgsnd(msgid, &m, sizeof(m.mtext), 0);
			break;
		}
	}
	
}

int main()
{
	//获取消息队列
	int msgid = msgget(MSGKEY, 0);   //键值（唯一）
	if (-1 == msgid)
	{
		perror("msgget");
		exit(1);
	}

	pid_t pid = fork();
	if (-1 == pid)
	{
		perror("fork");
		exit(1);
	}
	else if (0 == pid)
	{
		SendData(msgid);
	}
	else 
	{
		RecvData(msgid, pid);

		int status;
		wait(&status);
	}

	return 0;
}

共享内存

指的是被多个进程共享的一部分物理内存.共享内存是进程间共享数据的一种最快的方法，一个进程向共享内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容
共享内存实现分为两个步骤:
一、创建共享内存，使用shmget函数
二、映射共享内存，将这段创建的共享内存映射到具体的进程空间去，使用shmat函数
在这里插入图片描述

创建
int shmget ( key_t key, int size, int shmflg )
key标识共享内存的键值: 0/IPC_PRIVATE。
当key的取值为IPC_PRIVATE，则函数shmget()将创建一块新的共享内存；
如果key的取值为0，而参数shmflg中又设置IPC_PRIVATE这个标志，则同样会创建一块新的共享内存。
返回值：如果成功，返回共享内存标识符；如果失败，返回-1

映射
char * shmat ( int shmid, char *shmaddr, int flag)
参数：
shmid：shmget函数返回的共享存储标识符
flag：决定以什么方式来确定映射的地址（通常为0）
返回值：
如果成功，则返回共享内存映射到进程中的地址；如果失败，则返回- 1

当一个进程不再需要共享内存时，需要把它从进程地址空间中脱离。
int shmdt ( char *shmaddr )
在这里插入图片描述

已经创建好了的话，下一个访问共享内存，就下面的改动。

信号量

信号量(又名：信号灯)与其他进程间通信方式不大相同，主要用途是保护临界资源.
进程可以根据它判定是否能够访问某些共享资源。除了用于访问控制外，还可用于进程同步
二值信号灯：信号灯的值只能取0或1，类似于互斥锁。但两者有不同：
信号灯强调共享资源，只要共享资源可用，其他进程同样可以修改信号灯的值；
互斥锁更强调进程，占用资源的进程使用完资源后，必须由进程本身来解锁。
计数信号灯：信号灯的值可以取任意非负值
在这里插入图片描述

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.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 id)
{
	struct sembuf s;
	s.sem_num = 0;      //表示第一个信号量
	s.sem_op = -1;      //减一操作
	s.sem_flg = SEM_UNDO;      //如果某个进程访问数据的时候意外退出，信号量则恢复初始值

	int ret = semop(id, &s, 1);        //1表示只有一个信号量，只需要操作一次
	if (-1 == ret)
	{
		perror("semop1");
	}
}

void sem_v(int id)
{
	struct sembuf s;
	s.sem_num = 0;      //表示第一个信号量
	s.sem_op = 1;      //加一操作
	s.sem_flg = SEM_UNDO;      //如果某个进程访问数据的时候意外退出，信号量则恢复初始值

	int ret = semop(id, &s, 1);        //1表示只有一个信号量，只需要操作一次
	if (-1 == ret)
	{
		perror("semop2");
	}
}

int main()
{
	int num = 100;
	int shmid = shmget(SHMKEY, SHMSIZE, IPC_CREAT | IPC_EXCL);	  //创建共享内存
	if (-1 == shmid)
	{
		perror("shmget");
		exit(1);
	}

	void *addr = shmat(shmid, NULL, 0);  //NULL表示让操作系统自动选择可用的内存来映射
	if (NULL == addr)
	{
		perror("shmat");
		exit(1);
	}

	//创建一个信号量
	int semid = semget(SEMKEY, 1, IPC_CREAT | IPC_EXCL);    //1表示要创建的信号量的个数
	if (-1 == semid)
	{
		perror("semget");
		exit(1);
	}

	//初始化为二值信号量
	union semun s;
	s.val = 1;                          //二值信号量要求初始值为1
	int ret = semctl(semid, 0, SETVAL, s);   //0表示第一个  SETVAL表示设置初始值
	if (-1 == ret)
	{
		perror("semctl");
		exit(1);
	}
	
	*(int *)addr = num;     //把num写进共享内存

	while (1)
	{
		sem_p(semid);                                     //访问共享数据前，获取信号量 -1操作
		num = *(int *)addr;      //读数据
		if (num <= 0)
		{
			sem_v(semid);
			break;
		}
		printf("%d get num = %d\n", getpid(), num);

		num--;                //操作共享数据
		*(int *)addr = num;   //写数据
		sem_v(semid);                                     //访问完数据，释放信号量 +1操作

		usleep(1000);
	}

	usleep(100000);
	semctl(semid, 0, IPC_RMID);   //删除第0个信号量
	shmctl(shmid, IPC_RMID, NULL);

	return 0;
}

Linux相关的一些命令：
ipcs 查看所有信号，信息队列，管道…
ipcs -q 查看信息队列
ipcrm -q msqid 删除管道，信息队列，信号等等…
ipcs -m 查看共享内存

文曲尽墨琛乃缺

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Linux系统编程（三）进程间通信

进程间通信概述1.数据传输一个进程需要将它的数据发送给另一个进程2.资源共享多个进程之间共享同样的资源3.通知事件一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事件4.进程控制有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有操作，并能够及时知道它的状态改变现在Linux使用的进程间通信方式包括：1、管道（pipe）和...
复制链接

扫一扫