一、进程间通信方式

如果多个进程之间需要协同处理某个任务时，这时就需要进程间的同步和数据交流。常用的进程间通信（IPC，InterProcess Communication）的方法有：
1.信号（sinal）：信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。
2. 管道（Pipe）：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系（通常是指父子进程关系）。
3.命名管道FIFO：命名管道（Named Pipe）也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。
4. 命名socket或UNIX域socket（Named Socket或Unix Domain Socket）：socket也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同进程间的进程通信。
5. 信号量（Semaphore）：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
6. 共享存储（Shared Memory）：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。
7. 消息队列（Message Queue）：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。

二、有如下示例：

信号（signal）

信号是Linux系统中用于进程之间通信或操作的一种机制，信号可以在任何时候发送给某一进程，而无须知道该进程的状态。下面是一个父子进程之间使用信号进行同步的例程：

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
int g_child_stop = 0;
int g_parent_run = 0;
void sig_child(int signum)
{
   if( SIGUSR1 == signum )
   {
        g_child_stop = 1;
   }
}
void sig_parent(int signum)
{
   if( SIGUSR2 == signum )
   {
        g_parent_run = 1;
   }
}
int main(int argc, char **argv)
{
   int  pid;
   int  wstatus;
   signal(SIGUSR1, sig_child);
   signal(SIGUSR2, sig_parent);
   if( (pid=fork()) < 0 )
   {
      printf("Create child process failure: %s\n", strerror(errno));
      return -2;
   }
   else if(pid == 0)
   {
  /* child process can do something first here, then tell parent process    to start running */
      printf("Child process start running and send parent a signal\n");
      kill(getppid(), SIGUSR2);
   while( !g_child_stop )
  {
     sleep(1);
  }
 
 printf("Child process receive signal from parent and exit now\n");
 return 0;
 }
 printf("Parent hangs up untill receive signal from child!\n");
 while( !g_parent_run )
 {
     sleep(1);
 }
 /* parent process can do something here, then tell child process to exit */
     printf("Parent start running now and send child a signal to exit\n");
     kill(pid, SIGUSR1);
 /* parent wait child process exit */
     wait(&wstatus);
     printf("Parent wait child process die and exit now\n");
     return 0;
}

运行结果：
在这里插入图片描述
这个程序中，如果父进程先执行则进入到循环休眠等待状态，直到子进程给他发送信号之后才能跳出循环继续运行，这就可以确保子进程先执行它的任务。同样子进程在执行完成任务之后，就等待父进程给他发送信号之后才能退出，而父进程则通过调用wait()系统调用等待子进程退出后，父进程再退出。

管道（pipe）

管道是UNIX系统IPC的最古老的形式，所有的UNIX系统都提供此种通信机制。下面编写一个例程，用于父进程给子进程方向发送数据。

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
#define MSG_STR "This message is from parent: Hello, child process!"
int main(int argc, char **argv)
{
    int pipe_fd[2];
    int rv;
    int pid;
    char buf[512];
    int wstatus;
if( pipe(pipe_fd) < 0)
{
     printf("Create pipe failure: %s\n", strerror(errno));
     return -1;
}
if( (pid=fork()) < 0 )
{
     printf("Create child process failure: %s\n", strerror(errno));
     return -2;
 }
 else if(pid == 0)
 {
 /* child process close write endpoint, then read data from parent process */
   close(pipe_fd[1]);
   memset(buf, 0, sizeof(buf));
   rv=read(pipe_fd[0], buf, sizeof(buf));
 if(rv < 0 )
 {
     printf("Child process read from pipe failure: %s\n", strerror(errno));
     return -3;
 }
 
 printf("Child process read %d bytes data from pipe: \"%s\"\n", rv, buf);
 return 0;
 }
 
 /* parent process close read endpoint, then write data to child process */
 close(pipe_fd[0]);
 if( write(pipe_fd[1], MSG_STR, strlen(MSG_STR)) < 0)
 {
      printf("Parent process write data to pipe failure: %s\n",        strerror(errno));
      return -3;
 }
 printf("Parent start wait child process exit...\n");
 wait(&wstatus);
 return 0;
}

运行结果：
在这里插入图片描述
这个程序中，父进程创建管道之后fork()，这时子进程会继承父进程所有打开的文件描述符（包括管道），这时对于一个管道就有4个读写端（父子进程各有一对管道读写端），如果需要父进程往子进程里写数据，则需要在父进程中关闭读端，在子进程中关闭写端；而如果需要子线程往父进程中写数据，则可以在父进程关闭写端，然后子进程中关闭读端。