IO进程间的通信详解（嵌入式学习）

这次更新内容比较干巴，满满嚼，把例子敲一遍好好理解。如果您着急，请直接打开目录跳转到对您有价值的部分

进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。简单说就是进程之间可以相互发送数据。
IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。Socket用在网络编程中。

管道

管道分为无名管道和有名管道

无名管道 ——》pipe——》只能给有亲缘关系进程通信
有名管道 ——》fifo —— 》可以给任意单机进程通信

管道的特性：

管道是半双工的工作模式
所有的管道都是特殊的文件不支持定位操作。（lseek->> fd fseek ->>FILE* ）
管道是特殊文件，读写使用文件IO。（open,read,write,close）

无名管道(PIPE)

无名管道用于有亲缘关系的进程间的通信，管道字如其名，它就像在两个进程之间铺设了一条管道，进程通过管道进行数据交互。无名管道是没有名字的，它由pipe或者pipe2函数创建，与之对应的是有名管道。

特点

（1）只能用于具有亲缘关系的进程之间的通信
（2）单工管道，半双工通信模式，具有固定的读端和写端
（3）管道可以看成是一种特殊的文件，对于它的读写可以使用文件IO如read、write函数。
（4）管道是基于文件描述符的通信方式。当一个管道建立时，它会创建两个文件描述符fd[0]和fd[1]。其中fd[0]固定用于读管道，而fd[1]固定用于写管道。   	
（5）无名管道的操作属于一次性操作，如果对无名管道进行读操作，数据会被全部读走
（6）无名管道的大小是固定的，管道一旦满，写操作就会导致进程阻塞，管道的大小是64K。只有读出大于等于4K之后，写操作解除阻塞。 
（7）当管道中无数据时，执行读操作，读操作阻塞
（8）无名管道不保证操作的原子性，如果当前管道，满足读写条件，读写可同时进行。
（9）向无名管道中写去数据，将读端关闭，管道破裂，进程收到信号（SIGPIPE）,默认这个信号会将进程杀死 。
（10）当管道中有数据，将写端关闭，读操作可以执行，之后数据读完，可以继续读取（非阻塞），直接返回0。
（11）无需open，但需手动close。
（12）不支持如lseek() 操作。队列形式，先进先出，属于一次性操作。

使用方法

 #include 
 int pipe(int pipefd[2]);
 功能：创建无名管道
 参数：
    int pipefd[2]：数组的首地址，保存的是无名管到的两个文件描述符
    pipefd[0] - 读端
    pipefd[1] - 写端 
    数据从写端写入到管道，读端读出来。
返回值：
 成功 0  失败-1、更新errno

举个栗子

//例子：父进程中循环读文件内容写到管道中，子进程循环读管道内容写道一个新文件中
int main(int argc, char const *argv[])
{
    char buf[32];
    int fd[2],fd_src,fd_dest;
    int ret;
    if (pipe(fd) < 0){
        perror("pipe error");
        return 0;
    }
    pid_t pid = fork();
    if (pid < 0)
        perror("fork error");
    else if (pid == 0){
        close(fd[0]);
        fd_src = open(argv[1], O_RDONLY);
        if (fd_src < 0)
            perror("open src error");
        while ((ret = read(fd_src, buf, sizeof(buf))) != 0)
            write(fd[1], buf, ret);
    }
    else{
       close(fd[1]);
       fd_dest = open(argv[2], O_TRUNC | O_CREAT | O_WRONLY, 0666);
        if (fd_dest < 0)
            perror("open dest error");
        while ((ret = read(fd[0], buf, sizeof(buf))) != 0)
            write(fd_dest, buf, ret);
        wait(NULL);
    }
    close(fd[0]);
    close(fd[1]);
    close(fd_src);
    close(fd_dest);
}

有名管道(FIFO)

特点

（1）有名管道的创建之后会在文件系统中以管道文件的形式存在；
（2）有名管道可以用于任意两个进程间的通信，没有固定的读端和写端
（3）有名管道可以使互不相关的两个进程互相通信。
（4）有名管道可以通过路径名来指出，并且在文件系统中可见，但内容存放在内存中。
（5）进程通过文件IO来操作有名管道
（6）有名管道以队列的方式先进先出
（7）一次性操作，不支持lseek()

通过命令创建 
mkfifo my_fifo
$ mkfifo  filename  -m  mode      
mkfifo  myfifo   -m  0666(创建一个命名管道myfifo，其权限为0666)
创建管道文件成功后，只是对应在磁盘中有这个文件了，并没有对应的内存，只有在一个进程用open打开这个文件后，这个管道缓冲区(数组)才会开辟存在。close关闭后其缓冲区释放不存在。

使用方法

int mkfifo(const char *filename,mode_t mode);
	功能：创健有名管道
	参数：filename：有名管道文件名
		  mode：权限
	返回值：成功：0	
			失败：-1，并设置errno号	
			注意对错误的处理方式：
			如果错误是file exist时，注意加判断，如：
			if(errno == EEXIST)

以O_WRONLY打开管道，写阻塞
以O_RDONLY打开管道，读阻塞
以O_RDWR打开管道，管道中没有内容，读阻塞	
	
#include 
int system(const char *command);
功能：调用可执行命令，实现命令功能。
system("rm fifo");删除管道文件

举个栗子

int main(int argc, char const *argv[])
{
    int fd, fp;
    char a[32];
    if (mkfifo("./fifo", 0666) < 0)
    {
        if (errno == EEXIST)
            printf("file eexist\n");
        else
            perror("fifo err");
    }
    pid_t pid = fork();
    if (pid < 0)
        perror("err");
    else if (pid == 0)
    {
        fd = open("./fifo", O_RDONLY);
        if (fd < 0)
            perror("open err");
        while (1)
        {
            if (strcmp(a, "quit") == 0)
                break;
            printf("%s",a);
        }
    }
    else
    {
        fp = open("./fifo", O_WRONLY);
        if (fp < 0)
            perror("open err");
        while (1)
        {
            scanf("%s", a);
            if (strcmp(a, "quit") == 0)
                break;
            write(fp, a, 32);
        }
    }
    close(fd);
    return 0;
}

信号

概念

（1）信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式
（2）信号可以直接进行用户空间进程和内核进程之间的交互，内核
进程也可以利用它来通知用户空间进程发生了哪些系统事件。
（3）如果该进程当前并未处于执行态，则该信号就由内核保存起来，
直到该进程恢复执行再传递给它；如果一个信号被进程设置为阻塞，
则该信号的传递被延迟，直到其阻塞被取消时才被传递给进程。

响应方式

（1）忽略信号：对信号不做任何处理，但是有两个信号不能忽略：即SIGKILL及SIGSTOP。
（2）捕捉信号：定义信号处理函数，当信号发生时，执行相应的处理函数。
（3）执行缺省操作：Linux对每种信号都规定了默认操作

信号

SIGINT：ctrl+c  终止信号
SIGQUIT：ctrl+\ 终止信号
SIGTSTP:ctrl+z  暂停信号
SIGALRM：闹钟信号 收到此信号后定时结束，结束进程
SIGCHLD：子进程状态改变，父进程收到信号
SIGKILL：杀死信号
SIGSTOP：停止信号
SIGUSR1和SIGUSR2：未定义默认功能的信号

函数

1.信号发送

int kill(pid_t pid, int sig);
功能：信号发送
参数：pid：指定进程
	  sig：要发送的信号
返回值：成功 0
		失败 -1

2.进程向自己发送信号

int raise(int sig);
功能：进程向自己发送信号
参数：sig：信号
返回值：成功 0
		失败 -1

3.设置一个定时器

unsigned int alarm(unsigned int seconds)
功能：在进程中设置一个定时器
参数：seconds：定时时间，单位为秒
返回值：如果调用此alarm()前，进程中已经设置了闹钟时间，则
返回上一个闹钟时间的剩余时间，否则返回0。
	注意：一个进程只能有一个闹钟时间。如果在调用alarm时
已设置过闹钟时间，则之前的闹钟时间被新值所代替

4.将调用进程挂起直到收到信号为止

int pause(void);
功能：用于将调用进程挂起直到收到信号为止。

5.信号处理函数(注册信号)

void (*signal(int signum, void (*handler)(int)))(int);
   或者：
   typedef void (*sighandler_t)(int);	    
   sighandler_t signal(int signum, sighandler_t handler)  
功能：信号处理函数(注册信号)
参数：signum：要处理的信号
	  handler：SIG_IGN：忽略该信号。
			   SIG_DFL：采用系统默认方式处理信号。
			   自定义的信号处理函数指针
返回值：成功：设置之前的信号处理方式
		失败：SIG_ERR

举个栗子：(信号的知识实现司机和售票员问题)

/*用信号的知识实现司机和售票员问题。
1)售票员捕捉SIGINT（代表开车）信号，向司机发送SIGUSR1信号，司机打印（let's gogogo）
2）售票员捕捉SIGQUIT（代表停车）信号，向司机发送SIGUSR2信号，司机打印（stop the bus）
3）司机捕捉SIGTSTP（代表到达终点站）信号，向售票员发送SIGUSR1信号，售票员打印（please get off the bus）
4）司机等待售票员下车，之后司机再下车。
	 分析：
	 售票员：子进程
		捕捉：SIGINT  SIGQUIT  SIGUSR1
		忽略：SIGTSTP 
	 司机：父进程
		捕捉：SIGUSR1  SIGUSR2 SIGTSTP
		忽略：SIGINT SIGQUIT*/
#include 
#include 
#include 
#include 
#include 
#include 
pid_t pid;
void bus_handler(int sig)
{
    if (sig == SIGUSR1)
        printf("let's gogogo\n");
    if (sig == SIGUSR2)
        printf("stop the bus\n");
    if (sig == SIGTSTP)
        kill(pid, SIGUSR1);
}
void sal_handler(int sig)
{
    if (sig == SIGINT)
        kill(getppid(), SIGUSR1);
    if (sig == SIGQUIT)
        kill(getppid(), SIGUSR2);
    if (sig == SIGUSR1)
    {
        printf("please get off the bus\n");
        exit(-1);
    }
}
int main(int argc, char const *argv[])
{
    pid = fork();
    if (pid < 0)
        perror("fork err.");
    else if (pid == 0)
    {
        signal(SIGINT, sal_handler);
        signal(SIGQUIT, sal_handler);
        signal(SIGUSR1, sal_handler);
        signal(SIGTSTP, SIG_IGN);
        while (1)
            pause();
    }
    else
    {
        signal(SIGUSR1, bus_handler);
        signal(SIGUSR2, bus_handler);
        signal(SIGTSTP, bus_handler);
        signal(SIGINT, SIG_IGN);
        signal(SIGQUIT, SIG_IGN);
        wait(NULL);
    }
    return 0;
}

共享内存

特点

(1）共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存，而不需要任何数据的拷贝
(2）为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间
(3）进程就可以直接读写这一内存区而不需要进行数据的拷贝，从而大大提高的效率。
(4）由于多个进程共享一段内存，因此也需要依靠某种同步机制，
如互斥锁和信号量等

步骤

//ftok函数获取一个关键key值  
    ftok()
//创建一个共享内存或打开(key)-实际的物理内存空间
    shmget()
//建立共享内存和虚拟地址的映射
    shmat()
//取消映射
    shmdt()
//销毁共享内存
    shmctl()

函数

1.产生key值

key_t ftok(const char *pathname, int proj_id);
	功能：产生一个独一无二的key值
	参数：
		Pathname：已经存在的可访问文件的名字
		Proj_id：一个字符（因为只用低8位）
	返回值：成功：key值
			失败：-1，更新errno

2.创建或打开共享内存

int shmget(key_t key, size_t size, int shmflg);
	功能：创建或打开共享内存
    参数：
		key  键值
        size   共享内存的大小 
        shmflg   IPC_CREAT|IPC_EXCL|0777
          创建共性内存 | 判断是否存在，存在报错返回 | 共享内存的权限
	返回值：成功   shmid
            出错    -1，更新errno

查看共享内存的命令：ipcs 
    删除共享内存：ipcrm -M key    或     ipcrm -m shmid

3.映射共享内存

void  *shmat(int  shmid,const  void  *shmaddr,int  shmflg);
	功能：映射共享内存，即把指定的共享内存映射到进程的地址空间用于访问
    参数：
		shmid   共享内存的id号
        shmaddr   一般为NULL，表示由系统自动完成映射
                  如果不为NULL，那么有用户指定
        shmflg：SHM_RDONLY就是对该共享内存只进行读操作shm_rdonly
                0     可读可写		
	返回值：成功：完成映射后的地址，
			出错：-1地址
		用法：if((p = (char *)shmat(shmid，NULL,0)) == (char *)-1)

4.取消映射

int shmdt(const void *shmaddr);
	 功能：取消映射
	 参数：要取消的地址
	 返回值：成功0  
			失败的-1

5.删除共享内存

int  shmctl(int  shmid,int  cmd,struct  shmid_ds   *buf);
	功能：(删除共享内存)，对共享内存进行各种操作
	参数：
		shmid   共享内存的id号
      	cmd     IPC_STAT 获得shmid属性信息，存放在第三参数
             	IPC_SET 设置shmid属性信息，要设置的属性放在第三参数
                IPC_RMID:删除共享内存，此时第三个参数为NULL即可	
	返回：  成功0 
			失败-1
		用法：shmctl(shmid,IPC_RMID,NULL);

举个栗子

#include 
#include 
#include 
#include 
#include 
#include 
//创建一个KEY值
int main(int argc, char const *argv[])
{
    key_t key;
    key = ftok("./user1.c", 'B');
    if (key < 0)
    {
        perror("ftof err");
        return -1;
    }
    printf("key=%#x\n", key);

    //创建一个共享内存或打开(key),实际的物理内存空间
    int shmid = shmget(key, 128, IPC_CREAT | IPC_EXCL | 0666);

    if (shmid < 0)
    {
        if (errno == EEXIST)
        {
            shmid = shmget(key, 128, 0666);
        }
        else
        {
            perror("shmget err");
            return -1;
        }
    }
    printf("shmid=%d\n", shmid);
    //3.建立共享内存和虚拟地址的映射关系
    char *sp = (char *)shmat(shmid, NULL, 0);
    if (sp == (char *)-1)
    {
        perror("chmat err");
        return -1;
    }
    fgets(sp, 128, stdin);
    printf("%s\n", sp);
    //4.取消映射
    shmdt(sp);
    //5.销毁共享内存
    shmctl(shmid,IPC_RMID,NULL);
    return 0;
}

信号灯集

特点

信号灯(semaphore)，也叫信号量。它是不同进程间
 或一个给定进程内部不同线程间同步的机制
System V的信号灯是一个或者多个信号灯的一个集合。
 其中的每一个都是单独的计数信号灯。而Posix信号
 灯指的是单个计数信号灯

信号灯种类：

posix有名信号灯
posix基于内存的信号灯(无名信号灯)
System V信号灯(IPC对象)	

步骤

//创建key值
		ftok
//创建或打开信号灯集
		semid = semget(key, num, flag);
//初始化信号灯(赋初始的资源量)
		semctl(semid, 编号, SETVAL, union semun);
//PV操作
		semop(semid, struct sembuf, 1);
//删除信号灯集
		semctl(semid, 0, IPC_RMID);

函数

1.创建/打开信号灯

int semget(key_t key, int nsems, int semflg);
	功能：创建/打开信号灯
	参数：key：ftok产生的key值
	      nsems：信号灯集中包含的信号灯数目
	      semflg：信号灯集的访问权限，通常为IPC_CREAT|IPC_EXCL |0666
	返回值：成功：信号灯集IDIPC_EXCL
			失败：-1、更新errno

2.对信号灯集合中的信号量进行PV操作

int semop ( int semid, struct sembuf  *opsptr,  size_t  nops);
	功能：对信号灯集合中的信号量进行PV操作
	参数：semid：信号灯集ID
		  struct sembuf {
   			short  sem_num; // 要操作的信号灯的编号
   			short  sem_op;  
					//    0 :  等待，直到信号灯的值变成0
                    //   1  :  释放资源，V操作
                    //   -1 :  申请资源，P操作                    
   	     	short  sem_flg; 
				// 0（阻塞）,IPC_NOWAIT, SEM_UNDO
			};

	      nops:  要操作的信号灯的个数 1个
	返回值：成功 ：0
			失败：-1
	用法：
	   申请资源 P操作：  
		mysembuf.sem_num = 0;
		mysembuf.sem_op = -1;
		mysembuf.sem_flg = 0;
		semop(semid, &mysembuf, 1);
	   释放资源 V操作：
		mysembuf.sem_num = 0;
		mysembuf.sem_op = 1;
		mysembuf.sem_flg = 0;
		semop(semid, &mysembuf, 1);

3.信号灯集合的控制（初始化/删除）

int semctl ( int semid, int semnum,  int cmd…/*union semun arg*/);
	功能：信号灯集合的控制（初始化/删除）
	参数：semid：信号灯集ID
	      semnum: 要操作的集合中的信号灯编号
	      cmd：
			GETVAL：获取信号灯的值，返回值是获得值
			SETVAL：设置信号灯的值(资源量)，
			     需要用到第四个参数：共用体
			IPC_RMID：从系统中删除信号灯集合
	返回值：成功 0
			失败 -1
	用法：
	   初始化：
			union semun{
				int val;
			}mysemun;
			mysemun.val = 10;
			semctl(semid, 0, SETVAL, mysemun);	
	   获取信号灯值：函数semctl(semid, 0, GETVAL)的返回值
	   删除信号灯集：semctl(semid, 0, IPC_RMID);
	   
	查看信号灯集的命令：ipcs -s
	删除信号灯集的命令：ipcrm -s [semid]

举个栗子

#include 
#include 
#include 
#include 
#include 
union semval {
    int val;
};

int main(int argc, const char *argv[])
{
    key_t key;
    key = ftok("./a.txt", 'A');
    if (key < 0)
    {
        perror("ftok err.");
        return -1;
    }
    printf("key=%#x\n", key);
    int semid = semget(key, 2, IPC_CREAT | IPC_EXCL | 0666);
    if (semid < 0)
    {
        if (errno == EEXIST)
        {
            semid = semget(key, 2, 0666);
        }
        else
        {
            perror("semget err.");
            return -1;
        }
    }
    else 
    {
        //灯有两个：编号0 1
        union semval value;
        value.val = 5;
        semctl(semid, 0, SETVAL, value);
        value.val = 10;
        semctl(semid, 1, SETVAL, value);
    }

    //申请资源 p
    struct sembuf op;
    op.sem_num = 0; //0号灯
    op.sem_op = -1; //申请
    op.sem_flg = 0; //阻塞
    semop(semid, &op, 1);

    op.sem_num = 1; //1号灯
    op.sem_op = -1; //申请
    op.sem_flg = 0; //阻塞
    semop(semid, &op, 1);

    printf("0:%d 1:%d\n", semctl(semid, 0, GETVAL),
           semctl(semid, 1, GETVAL));
    //获取剩余的资源量
    return 0;
}

消息队列

特点：

消息队列是IPC对象的一种
消息队列由消息队列ID来唯一标识
消息队列就是一个消息的列表。用户可以在消息队列
  中添加消息、读取消息等。
消息队列可以按照类型来发送/接收消息

步骤：

（1）产生key值ftok
（2）创建或打开消息队列
（3）添加消息：按照类型把消息添加到已打开的消息队列末尾
（4）读取消息：可以按照类型把消息从消息队列中取走
（5）删除消息队列

函数：

1.创建或打开消息队列

int msgget(key_t key, int flag);
功能：创建或打开一个消息队列
参数：  key值
		flag：创建消息队列的权限IPC_CREAT|IPC_EXCL|0666
返回值：成功：msgid
		失败：-1

2.添加消息

int msgsnd(int msqid, const void *msgp, size_t size, int flag); 
功能：添加消息
参数：msqid：消息队列的ID
      msgp：指向消息的指针。常用消息结构msgbuf如下：
		struct msgbuf{
			long mtype;          //消息类型
			char mtext[N];
			}；   //消息正文
      size：发送的消息正文的字节数
      flag：IPC_NOWAIT消息没有发送完成函数也会立即返回	
	        0：直到发送完成函数才返回
返回值：成功：0
		失败：-1
使用：msgsnd(msgid, &msg,sizeof(msg)-sizeof(long), 0)
注意：消息结构除了第一个成员必须为long类型外，其他成员可以根据应用的需求自行定义。

3.读取消息

 int msgrcv(int msgid,  void* msgp,  size_t  size,  long msgtype,  int  flag);
	功能：读取消息
	参数：msgid：消息队列的ID
	      msgp：存放读取消息的空间
	      size：接受的消息正文的字节数
	      msgtype：
			0：接收消息队列中第一个消息。
			大于0：接收消息队列中第一个类型为msgtyp的消息.
			小于0：接收消息队列中类型值不小于msgtyp的绝对值且类型值又最小的消息。
	      flag：0：若无消息函数会一直阻塞
			IPC_NOWAIT：若没有消	息，进程会立即返回ENOMSG
	返回值：成功：接收到的消息的长度
			失败：-1

4.删除消息队列

int msgctl ( int msgqid, int cmd, struct msqid_ds *buf );
	功能：对消息队列的操作，删除消息队列
	参数：msqid：消息队列的队列ID
	      cmd：
			IPC_STAT：读取消息队列的属性，并将其保存在
			    buf指向的缓冲区中。
			IPC_SET：设置消息队列的属性。这个值取自buf参数。
			IPC_RMID：从系统中删除消息队列。
	      buf：消息队列缓冲区
	返回值：成功：0
			失败：-1
	用法：msgctl（msgid, IPC_RMID, NULL）

举个栗子

#include 
#include 
#include 
#include 
#include 
struct msgbuf
{
    long mtype;
    char mtext[128];
};
int main(int argc, char const *argv[])
{
    key_t key = ftok("./a.txt", 'A');
    if (key < 0)
        perror("ftok err.");
    int msgid = msgget(key, IPC_CREAT | IPC_EXCL | 0666);
    if (msgid < 0)
    {
        if (errno == EEXIST)
            msgid = msgget(key, 0666);
        else
            perror("msgget err.");
    }
    struct msgbuf msg = {'A', "hello world"};
    msgsnd(msgid, &msg, sizeof(msg), 0);
    struct msgbuf msg1 = {'B', "welcome to JiaYu学长"};
    msgsnd(msgid, &msg1, sizeof(msg1), 0);
    msgrcv(msgid, &msg, sizeof(msg), 'A', 0);
    printf("type:%ld text:%s\n", msg.mtype, msg.mtext);
    msgrcv(msgid, &msg, sizeof(msg), 'B', 0);
    printf("type:%ld text:%s\n", msg.mtype, msg.mtext);
    return 0;
}