Linux系统编程学习之进程间通信

管道（pipe）

管道的通信方式是单向半双工的，只能一端写入，而另一端读出。
管道分为两种，匿名管道和命名管道

匿名管道

无名管道是在父进程和子进程间单向传输数据的一种未命名的管道，只能在本地计算机中使用，而不可用于网络间的通信。

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

int main(int argc, char const *argv[])
{
	int fd[2];
	char buf[128] = {0};
	if (pipe(fd) == -1)
	{
		printf("%s\n", "管道开辟失败");
	}
	pid_t pid = fork();
	if (pid > 0)
	{
		sleep(1);
		printf("%s\n", "这是父进程");
		close(fd[0]);
		write(fd[1], "父进程写入", strlen("父进程写入"));
	}else if (pid == 0)
	{
		printf("%s\n", "这是子进程");
		close(fd[1]);
		read(fd[0], buf, 128);
		printf("读取到的为 == %s\n", buf);
	}
	return 0;
}

fd（0）是读端，fd（1）是写端，无名管道的使用必须手动关闭不需要的端口，
代码中设定父进程写入，就关闭父进程的读端fd（0），子进程读出，就关闭子进程的写端fd（1）；

命名管道

命名管道也被称为FIFO文件，它是一种特殊类型的文件，它在文件系统中以文件名的形式存在，和匿名管道一样，只能一端只读，一端只写，但可以不限于父子进程间的通信，可实现两个不相关进程间的通信。

#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *filename, mode_t mode);
int mknod(const char *filename, mode_t mode | S_IFIFO, (dev_t)0);

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

int main()
{
	pid_t pid;
	int ret = mkfifo("./file", 0600);
	if(ret == -1 && errno != EEXIST){
		perror("why");
	}
	pid = fork();
	if(pid > 0){
		int fd1;
		fd1 = open("./file", O_WRONLY);
		while(1){
			write(fd1, "hello", 10);
			sleep(3);
		}	
	}if(pid == 0){
		int fd2;
		fd2 = open("./file", O_RDONLY);
		char buf[128] = {0};
		sleep(1);
		while(1){
			lseek(fd2, 0, SEEK_SET);
			read(fd2, buf, 128);
			printf("child find is %s\n", buf);
			sleep(3);
			}
		}	
	
	return 0;
}

消息队列

消息队列是消息的链表，存放在内存中，由Linux内核维护，每个消息队列都有自己的标识符，消息队列允许一个或多个进程向它写入或者读取消息，消息队列可以实现消息的随机查询。消息不一定要以先进先出的次序读取，编程时可以按消息的类型读取。但是在一个进程对消息队列进行访问的时候，另一个进程无法同时对该消息队列进行访问。

       #include <sys/types.h>
       #include <sys/ipc.h>
       #include <sys/msg.h>
       
       int msgget(key_t key, int msgflg);
       
       int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

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

       int msgctl(int msqid, int cmd, struct msqid_ds *buf);

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

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

int main(int argc, char const *argv[])
{
	key_t key;
	key = ftok(".", 1);
	int msgId = msgget(key, IPC_CREAT|0777);
	printf("%x\n",key );
	if (msgId == -1)
	{
		printf("%s\n", "失败");
	}
	struct msgbuf rcvBuf;
	msgrcv(msgId, &rcvBuf, sizeof(rcvBuf.mtext), 666,0);
	printf("接收到的消息是 %s\n", rcvBuf.mtext);

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

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

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

int main(int argc, char const *argv[])
{
	key_t key = ftok(".", 1);
	int msgId = msgget(key, IPC_CREAT|0777);
	printf("%x\n", key);
	if (msgId == -1)
	{
		printf("%s\n", "失败");
	}
	struct msgbuf sndBuf = {666, "hello world !!"};
	msgsnd(msgId, &sndBuf, strlen(sndBuf.mtext), 0);

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

共享内存

共享内存是允许两个不相关进程访问访问同一个一个逻辑内存， 是同时运行的进程数据共享，互相通信的一种非常有效的方式。 共享内存与消息队列不同的地方在于，共享内存可以实现一个进程在对共享内存进行写入操作时，另一个进程可以即时读到写入的消息

shmwrite.c

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

int main(int argc, char const *argv[])
{
	char *shmaddr;
	key_t key = ftok(".",1);	
	int shmId = shmget(key, 1024, IPC_CREAT|0600);
	if (shmId == -1)
	{
		printf("%s\n", "共享内存创建失败");
	}
	shmaddr = shmat(shmId, 0, 0);
	strcpy(shmaddr, "hello world");
	printf("%s\n", "写入成功");
	sleep(5);
	shmdt(shmaddr);
	shmctl(shmId, IPC_RMID,0);
	printf("%s\n", "退出成功");
	return 0;
}

shmread.c

#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>

int main(int argc, char const *argv[])
{
	key_t key = ftok(".",1);
	int shmId = shmget(key, 1024, 0);
	char *shmaddr = shmat(shmId, 0, 0);
	printf("%s\n", "连接成功");
	printf("%s\n", shmaddr);
	shmdt(shmaddr);

	return 0;
}

信号

信号量