进程通信

进程通信

① 管道 (使用最简单)
② 信号 (开销最小)
③ 共享映射区 (无血缘关系)
④ 本地套接字 (最稳定)

管道

管道是一种最基本的IPC机制，作用于有血缘关系的进程之间，完成数据传递。
调用pipe系统函数即可创建一个管道。有如下特质：
1. 其本质是一个伪文件(实为内核缓冲区) 
2. 由两个文件描述符引用，一个表示读端，一个表示写端。
3. 规定数据从管道的写端流入管道，从读端流出。
管道的原理: 管道实为内核使用环形队列机制，借助内核缓冲区(4k)实现。
管道的局限性：
① 数据自己读不能自己写。
② 数据一旦被读走，便不在管道中存在，不可反复读取。
③ 由于管道采用半双工通信方式。因此，数据只能在一个方向上流动。
④ 只能在有公共祖先的进程间使用管道。

pipe函数

int pipe(int pipefd[2]);		成功：0；失败：-1，设置errno
函数调用成功返回r/w两个文件描述符。无需open，但需手动close。规定：fd[0] → r； fd[1] → w，就像0对应标准输入，1对应标准输出一样。向管道文件读写数据其实是在读写内核缓冲区。

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

int main(void)
{
	pid_t pid;
	int fd[2];
	pipe(fd);
	pid = fork();
	if (pid == 0) {  //child
		close(fd[1]);	                //子进程从管道中读数据，关闭写端
		dup2(fd[0], STDIN_FILENO);		//让wc从管道中读取数据
		execlp("wc", "wc", "-l", NULL);	//wc命令默认从标准读入取数据

	} else {
		close(fd[0]);	//父进程向管道中写数据，关闭读端
		dup2(fd[1], STDOUT_FILENO);		//将ls的结果写入管道中
		execlp("ls", "ls", NULL);		//ls输出结果默认对应屏幕
	}
	return 0;
}

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

int main(void)
{
	pid_t pid;
	int fd[2], i;
	pipe(fd);
	for (i = 0; i < 2; i++) {
		if((pid = fork()) == 0) {
			break;
        }
    }
	if (i == 0) {			//兄
		close(fd[0]);				//写,关闭读端
		dup2(fd[1], STDOUT_FILENO);		
		execlp("ls", "ls", NULL);	
	} else if (i == 1) {	//弟
		close(fd[1]);				//读，关闭写端
		dup2(fd[0], STDIN_FILENO);		
		execlp("wc", "wc", "-l", NULL);		
	} else {
        close(fd[0]);
        close(fd[1]);
		for(i = 0; i < 2; i++)		//两个儿子wait两次
			wait(NULL);
	}
	return 0;
}

FIFO

FIFO常被称为命名管道，以区分管道(pipe)。
管道(pipe)只能用于“有血缘关系”的进程间。但通过FIFO，不相关的进程也能交换数据。
FIFO是Linux基础文件类型中的一种。
但，FIFO文件在磁盘上没有数据块，仅仅用来标识内核中一条通道。\
各进程可以打开这个文件进行read/write，实际上是在读写内核通道，这样就实现了进程间通信。
创建方式：
1. 命令：mkfifo 管道名
2. 库函数：int mkfifo(const char *pathname,  mode_t mode);  成功：0； 失败：-1
一旦使用mkfifo创建了一个FIFO，就可以使用open打开它，常见的文件I/O函数都可用于fifo。
如：close、read、write、unlink等。

mkfifo fifo 创建管道

写：

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
void sys_err(char *str)
{
    perror(str);
    exit(-1);
}
int main(int argc, char *argv[])
{
    int fd, i;
    char buf[4096];
    if (argc < 2) {
        printf("Enter like this: ./a.out fifoname\n");
        return -1;
    }
    fd = open(argv[1], O_WRONLY);
    if (fd < 0) 
        sys_err("open");
    i = 0;
    while (1) {
        sprintf(buf, "hello itcast %d\n", i++);
        write(fd, buf, strlen(buf));
        sleep(1);
    }
    close(fd);
    return 0;
}

读：

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
void sys_err(char *str)
{
    perror(str);
    exit(1);
}
int main(int argc, char *argv[])
{
    int fd, len;
    char buf[4096];
    if (argc < 2) {
        printf("./a.out fifoname\n");
        return -1;
    }
    fd = open(argv[1], O_RDONLY);
    if (fd < 0) 
        sys_err("open");
    while (1) {
        len = read(fd, buf, sizeof(buf));
        write(STDOUT_FILENO, buf, len);
        sleep(3);           //多個读端时应增加睡眠秒数,放大效果.
    }
    close(fd);
    return 0;
}

共享存储映射

存储映射I/O (Memory-mapped I/O) 使一个磁盘文件与存储空间中的一个缓冲区相映射。
于是当从缓冲区中取数据，就相当于读文件中的相应字节。
于此类似，将数据存入缓冲区，则相应的字节就自动写入文件。
这样，就可在不适用read和write函数的情况下，使用地址（指针）完成I/O操作。
使用这种方法，首先应通知内核，将一个指定文件映射到存储区域中。
这个映射工作可以通过mmap函数来实现。

mmap函数

void *mmap(void *adrr, size_t length, int prot, int flags, int fd, off_t offset); 
返回：成功：返回创建的映射区首地址；失败：MAP_FAILED宏
参数：	
addr: 	建立映射区的首地址，由Linux内核指定。使用时，直接传递NULL
length： 欲创建映射区的大小
prot：	映射区权限PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE
flags：	标志位参数(常用于设定更新物理区域、设置共享、创建匿名映射区)
	  	MAP_SHARED:  会将映射区所做的操作反映到物理设备（磁盘）上。
	  	MAP_PRIVATE: 映射区所做的修改不会反映到物理设备。
fd： 	用来建立映射区的文件描述符
offset： 	映射文件的偏移(4k的整数倍)

munmap函数

同malloc函数申请内存空间类似的，mmap建立的映射区在使用结束后也应调用类似free的函数来释放。
int munmap(void *addr, size_t length);	成功：0； 失败：-1

使用mmap时务必注意以下事项：
1.创建映射区的过程中，隐含着一次对映射文件的读操作。
2.当MAP_SHARED时，要求：映射区的权限应 <=文件打开的权限(出于对映射区的保护)。
	而MAP_PRIVATE则无所谓，因为mmap中的权限是对内存的限制。
3.映射区的释放与文件关闭无关。只要映射建立成功，文件可以立即关闭。
4.特别注意，当映射文件大小为0时，不能创建映射区。
	所以：用于映射的文件必须要有实际大小！！	
	mmap使用时常常会出现总线错误，通常是由于共享文件存储空间大小引起的。
5.munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作。
6.如果文件偏移量必须为4K的整数倍
7.mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。

#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/mman.h>
void sys_err(char *str)
{
    perror(str);
    exit(1);
}
int main(void)
{
    char *mem;
    int len = 0;
    int fd = open("hello244", O_RDWR|O_CREAT|O_TRUNC, 0644);
    //int fd = open("dict.txt", O_RDWR);
    if (fd < 0)
        sys_err("open error");
    ftruncate(fd, 20);
/*
    len = lseek(fd, 3, SEEK_SET);   //获取文件大小,根据文件大小创建映射区
    write(fd, "e", 1);              //实质性完成文件拓展
    */
    printf("The length of file = %d\n", len);

    mem = mmap(NULL, 20, PROT_WRITE, MAP_SHARED, fd, 0);
    if (mem == MAP_FAILED)            //出错判断
        sys_err("mmap err: ");
    close(fd);

    strcpy(mem, "xxx");
    printf("%s\n", mem);

    if (munmap(mem,  4) < 0)
        sys_err("munmap");

    return 0;
}

匿名映射

通过使用我们发现，使用映射区来完成文件读写操作十分方便，父子进程间通信也较容易。
但缺陷是，每次创建映射区一定要依赖一个文件才能实现。
通常为了建立映射区要open一个temp文件，创建好了再unlink、close掉，比较麻烦。
 可以直接使用匿名映射来代替。其实Linux系统给我们提供了创建匿名映射区的方法，无需依赖一个文件即可创建映射区。
 同样需要借助标志位参数flags来指定。
使用MAP_ANONYMOUS (或MAP_ANON)， 如: 
int *p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0); 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
int main(void)
{
	int *p;
	pid_t pid;
	p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);  //MAP_ANONYMOUS
	if(p == MAP_FAILED){		//注意:不是p == NULL
		perror("mmap error");
		exit(1);
	}
	pid = fork();				//创建子进程
	if(pid == 0){
		*p = 2000;
		printf("child, *p = %d\n", *p);
	} else {
		sleep(1);
		printf("parent, *p = %d\n", *p);
	}
	munmap(p, 4);				//释放映射区
	return 0;
}

mmap无血缘关系进程间通信

实质上mmap是内核借助文件帮我们创建了一个映射区，多个进程之间利用该映射区完成数据传递。
由于内核空间多进程共享，因此无血缘关系的进程间也可以使用mmap来完成通信。
只要设置相应的标志位参数flags即可。若想实现共享，当然应该使用MAP_SHARED了。

写：

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

struct STU {
    int id;
    char name[20];
    char sex;
};
void sys_err(char *str)
{
    perror(str);
    exit(1);
}
int main(int argc, char *argv[])
{
    int fd;
    struct STU student = {10, "xiaoming", 'm'};
    char *mm;
    if (argc < 2) {
        printf("./a.out file_shared\n");
        exit(-1);
    }

    fd = open(argv[1], O_RDWR | O_CREAT, 0664);
    ftruncate(fd, sizeof(student));
    mm = mmap(NULL, sizeof(student), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if (mm == MAP_FAILED)
        sys_err("mmap");
    close(fd);
    while (1) {
        memcpy(mm, &student, sizeof(student));
        student.id++;
        sleep(1);
    }
    munmap(mm, sizeof(student));
    return 0;
}

读：

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

struct STU {
    int id;
    char name[20];
    char sex;
};
void sys_err(char *str)
{
    perror(str);
    exit(-1);
}
int main(int argc, char *argv[])
{
    int fd;
    struct STU student;
    struct STU *mm;
    if (argc < 2) {
        printf("./a.out file_shared\n");
        exit(-1);
    }
    fd = open(argv[1], O_RDONLY);
    if (fd == -1)
        sys_err("open error");
    mm = mmap(NULL, sizeof(student), PROT_READ, MAP_SHARED, fd, 0);
    if (mm == MAP_FAILED)
        sys_err("mmap error");
  
    close(fd);

    while (1) {
        printf("id=%d\tname=%s\t%c\n", mm->id, mm->name, mm->sex);
        sleep(2);
    }

    munmap(mm, sizeof(student));

    return 0;
}

shm函数实现进程通信

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

int shmget(key_t key, size_t size, int shmflg);

shmget函数用来获取或创建共享内存
参数key是共享内存的键值，是一个整数，typedef unsigned int key_t，是共享内存在系统中的编号，不同共享内存的编号不能相同，这一点由程序员保证。key用十六进制表示比较好。
参数size是待创建的共享内存的大小，以字节为单位。参数shmflg是共享内存的访问权限，与文件的权限一样，0666|IPC_CREAT表示全部用户对它可读写，如果共享内存不存在，就创建一个共享内存。

void *shmat(int shm_id, const void *shm_addr, int shmflg);

把共享内存连接到当前进程的地址空间
参数shm_id是由shmget函数返回的共享内存标识。参数shm_addr指定共享内存连接到当前进程中的地址位置，通常为空，表示让系统来选择共享内存的地址。
参数shm_flg是一组标志位，通常为0。
调用成功时返回一个指向共享内存第一个字节的指针，如果调用失败返回-1.

int shmdt(const void *shmaddr);

该函数用于将共享内存从当前进程中分离，相当于shmat函数的反操作
参数shmaddr是shmat函数返回的地址。
调用成功时返回0，失败时返回-1.

int shmctl(int shm_id, int command, struct shmid_ds *buf);

参数shm_id是shmget函数返回的共享内存标识符。
参数command填IPC_RMID。
参数buf填0。
解释一下，shmctl是控制共享内存的函数，其功能不只是删除共享内容，但其它的功能没什么用，所以不介绍了。
注意，用root创建的共享内存，不管创建的权限是什么，普通用户无法删除。

共享内存/条件变量实现进程通信

producer.cpp

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

struct sharedmemory
{
    pthread_mutex_t mtx;
    pthread_cond_t has_product;
    char buf[100];
    bool empty;
};

int main()
{
    int shmid;
    shmid = shmget((key_t)0x555, sizeof(struct sharedmemory), 0666 | IPC_CREAT);
    if (shmid < 0)
    {
        printf("shmget failed\n");
        exit(-1);
    }
    printf("shmid=%d\n", shmid);
    struct sharedmemory *ptr = (sharedmemory *)shmat(shmid, 0, 0);

    pthread_mutexattr_t mutexAttr;
    pthread_condattr_t condAttr;

    pthread_mutexattr_init(&mutexAttr);
    pthread_mutexattr_setpshared(&mutexAttr,PTHREAD_PROCESS_SHARED);
    pthread_condattr_init(&condAttr);
    pthread_condattr_setpshared(&condAttr,PTHREAD_PROCESS_SHARED);
    pthread_mutex_init(&ptr->mtx,&mutexAttr);
    pthread_cond_init(&ptr->has_product,&condAttr);
    // ptr->has_product=PTHREAD_COND_INITIALIZER;
    // ptr->mtx=PTHREAD_MUTEX_INITIALIZER;
    //ptr->empty = true;

    char data[100]={'\0'};
    while (true)
    {
        printf("please input:\n");
        fgets(data,100,stdin);
        pthread_mutex_lock(&(ptr->mtx));
        strcpy(ptr->buf, data);
        //ptr->empty=false;
        pthread_mutex_unlock(&(ptr->mtx));
        pthread_cond_signal(&ptr->has_product);

    }
}

consummer.cpp

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

struct sharedmemory
{
    pthread_mutex_t mtx;
    pthread_cond_t has_product;
    char buf[100];
    bool empty;
};

void callback(const char * s){

    printf("callback is doing\n");
    printf("msg=%s\n",s);
}

void *consumer(void *)
{
    int shmid;
    shmid = shmget((key_t)0x555, sizeof(struct sharedmemory), 0666 | IPC_CREAT);
    if (shmid < 0)
    {
        printf("shmget failed\n");
        exit(-1);
    }
    printf("shmid=%d\n",shmid);
    struct sharedmemory *p = (sharedmemory *)shmat(shmid, 0, 0);
   // while (p->empty){;}

    while (true)
    {
        pthread_mutex_lock(&(p->mtx));
        // while (p->empty)
        // {
        //     printf("begin waiting\n");
        //     pthread_cond_wait(&(p->has_product), &(p->mtx));
        // }
        printf("begin waiting\n");
        pthread_cond_wait(&p->has_product,&p->mtx);
        callback(p->buf);
        //p->empty = true;
        pthread_mutex_unlock(&(p->mtx));
    }
}


int main()
{
    pthread_t cid;
    pthread_create(&cid, NULL, consumer, NULL);
    pthread_join(cid, NULL);
}