2017-2018-1 20155302 课下实践IPC

共享内存

共享内存允许两个或多个进程共享一定的存储区，因为不需要拷贝数据，所以这是最快的一种IPC。
共享内存是在多个进程之间共享内存区域的一种进程间的通信方式，由IPC为进程创建的一个特殊地址范围，它将出现在该进程的地址空间（这里的地址空间具体是哪个地方？）中。其他进程可以将同一段共享内存连接到自己的地址空间中。所有进程都可以访问共享内存中的地址，就好像它们是malloc分配的一样。如果一个进程向共享内存中写入了数据，所做的改动将立刻被其他进程看到。
共享内存是IPC最快捷的方式，因为共享内存方式的通信没有中间过程，而管道、消息队列等方式则是需要将数据通过中间机制进行转换。共享内存方式直接将某段内存段进行映射，多个进程间的共享内存是同一块的物理空间，仅仅映射到各进程的地址不同而已，因此不需要进行复制，可以直接使用此段空间。

#include <sys/ipc.h>
#include <sys/shm.h>
(1)创建或访问共享内存
    * int shmget(key_t key,size_t size,int shmflg);

(2)附加共享内存到进程的地址空间
    * void *shmat(int shmid,const void *shmaddr,int shmflg);//shmaddr通常为NULL，由系统选择共享内存附加的地址;shmflg可以为SHM_RDONLY

(3)从进程的地址空间分离共享内存
    * int shmdt(const void *shmaddr); //shmaddr是shmat()函数的返回值

(4)控制共享内存
    * int shmctl(int shmid,int cmd,struct shmid_ds *buf);
    * struct shmid_ds{
          struct ipc_perm shm_perm;
          …
      }; 
cmd的常用取值有:(a)IPC_STAT获取当前共享内存的shmid_ds结构并保存在buf中(2)IPC_SET使用buf中的值设置当前共享内存的shmid_ds结构(3)IPC_RMID删除当前共享内存

代码实例：
建立共享内存并写入数据的程序

#include <stdio.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <errno.h>
void get_buf(char *buf)
{
    int i=0;
    while((buf[i]=getchar())!=‘\n‘&&i<1024)
        i++;
}
int main(void)
{
    int shmid;
    shmid=shmget(IPC_PRIVATE,sizeof(char)*1024,IPC_CREAT|0666);
    if(shmid==-1)
    {
        perror("shmget");
    }
    char *buf;
    if((int)(buf=shmat(shmid,NULL,0))==-1)
    {
        perror("shmat");
        exit(1);
    }
    get_buf(buf);
    printf("%d\n",shmid);
    return 0;
}

读取数据的程序

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
int main(int argc,char **argv)
{
    int shmid;
    shmid=atoi(argv[1]);
    char *buf;
    if((int)(buf=shmat(shmid,NULL,0))==-1)
    {
        perror("shmat");
        exit(1);
    }
    printf("%s\n",buf);
    shmdt(buf);
    return 0;
}

管道

管道的特点：
1、管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；
2、只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）。比如fork或exec创建的新进程，在使用exec创建新进程时，需要将管道的文件描述符作为参数传递给exec创建的新进程。当父进程与使用fork创建的子进程直接通信时，发送数据的进程关闭读端，接受数据的进程关闭写端。
3、单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。
4、数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。

(1)在两个程序之间传递数据的最简单的方法是使用popen()和pclose()函数:
    #include <stdio.h>
    FILE *popen(const char *command, const char *open_mode);
    int pclose(FILE *stream);
popen()函数首先调用一个shell，然后把command作为参数传递给shell。这样每次调用popen()函数都需要启动两个进程；但是由于在Linux中，所有的参数扩展(parameter expansion)都是由shell执行的，这样command中包含的所有参数扩展都可以在command程序启动之前完成。

(2)pipe()函数:
    #include <unistd.h>
    int pipe(int pipefd[2]);
popen()函数只能返回一个管道描述符，并且返回的是文件流(file stream)，可以使用函数fread()和fwrite()来访问。pipe()函数可以返回两个管道描述符:pipefd[0]和pipefd[1]，任何写入pipefd[1]的数据都可以从pipefd[0]读回；pipe()函数返回的是文件描述符(file descriptor)，因此只能使用底层的read()和write()系统调用来访问。pipe()函数通常用来实现父子进程之间的通信。

(3)命名管道:FIFO
    #include <sys/types.h>
    #include <sys/stat.h>
    int mkfifo(const char *fifo_name, mode_t mode);

代码实例：

read端

#include<stdlib.h> 
#include<stdio.h> 
#include<sys/types.h> 
#include<sys/stat.h> 
#include<fcntl.h> 
#include<errno.h> 
#define PATH "./fifo" 
#define SIZE 128 
int main() 
{ 
 umask(0); 
 if (mkfifo (PATH,0666|S_IFIFO) == -1) 
 { 
 perror ("mkefifo error"); 
 exit(0); 
 } 
 int fd = open (PATH,O_RDONLY); 
 if (fd<0) 
 { 
  printf("open fd is error\n"); 
  return 0; 
 } 
 
 char Buf[SIZE]; 
 while(1){ 
 ssize_t s = read(fd,Buf,sizeof(Buf)); 
 if (s<0) 
 { 
  perror("read error"); 
  exit(1); 
 } 
 else if (s == 0) 
 { 
  printf("client quit! i shoud quit!\n"); 
  break; 
 } 
 else 
 { 
  Buf[s] = ‘\0‘; 
  printf("client# %s ",Buf); 
  fflush(stdout); 
 } 
 } 
 close (fd); 
 return 3; 
} 

write端

#include<stdlib.h> 
#include<stdio.h> 
#include<unistd.h> 
#include<sys/types.h> 
#include<sys/stat.h> 
#include<string.h> 
#include<errno.h> 
#include<fcntl.h> 
 
#define PATH "./fifo" 
#define SIZE 128 
int main() 
{ 
 int fd = open(PATH,O_WRONLY); 
 if (fd < 0) 
 { 
  perror("open error"); 
  exit(0); 
 } 
 
 char Buf[SIZE]; 
 while(1) 
 { 
  printf("please Enter#:"); 
  fflush(stdout); 
  ssize_t s = read(0,Buf,sizeof(Buf)); 
  if (s<0) 
  { 
   perror("read is failed"); 
   exit(1); 
  } 
  else if(s==0) 
  { 
   printf("read is closed!"); 
   return 1; 
  } 
  else{ 
   Buf[s]= ‘\0‘; 
   write(fd,Buf,strlen(Buf)); 
  } 
 } 
 return 0; 
} 

FIFO（命名管道）

管道和命名管道的区别：

对于命名管道FIFO来说，IO操作和普通管道IO操作基本一样，但是两者有一个主要的区别，在命名管道中，管道可以是事先已经创建好的，比如我们在命令行下执行
mkfifo myfifo
就是创建一个命名通道，我们必须用open函数来显示地建立连接到管道的通道，而在管道中，管道已经在主进程里创建好了，然后在fork时直接复制相关数据或者是用exec创建的新进程时把管道的文件描述符当参数传递进去。
一般来说FIFO和PIPE一样总是处于阻塞状态。也就是说如果命名管道FIFO打开时设置了读权限，则读进程将一直阻塞，一直到其他进程打开该FIFO并向管道写入数据。这个阻塞动作反过来也是成立的。如果不希望命名管道操作的时候发生阻塞，可以在open的时候使用O_NONBLOCK标志，以关闭默认的阻塞操作。

FIFO可以说是管道的推广，克服了管道无名字的限制，使得无亲缘关系的进程同样可以采用先进先出的通信机制进行通信。
管道和FIFO的数据是字节流，应用程序之间必须事先确定特定的传输"协议"，采用传播具有特定意义的消息。
要灵活应用管道及FIFO，理解它们的读写规则是关键。

代码实例：

接收消息：

  #include                 <stdio.h>   
  #include                 <sys/types.h>   
  #include                 <sys/stat.h>   
  #include                 <string.h>   
  #include                 <fcntl.h>   
  #include                 <errno.h>   
  #include                 <sys/time.h>   
  #include                 <unistd.h>   
    
  #define   FIFO         "/tmp/fifo.temp1"   
  #define   MAXLINE   1024   
    
  int   main(void)   
  {   
       int           fifo,   fd;   
       char         buf[MAXLINE];   
       int           len;   
       fd_set     set;   
       struct     timeval   tv;   
       int           i   =   0;   
    
       unlink(FIFO);   //如果FIFO存在，就先删除   
       if   ((fifo   =   mkfifo(FIFO,   O_RDWR))   <   0)       //产生一个有名管道   
       {   
            printf("mkfifo   error:   %s/n",   strerror(errno));   
            return(0);   
       }   
       if   ((fd   =   open(FIFO,   O_RDWR))   <   0)               //读写打开有名管道   
       {   
            printf("open   error:   %s/n",   strerror(errno));   
            return(0);   
       }   
       FD_ZERO(&set);   
       FD_SET(fd,   &set);   
       tv.tv_sec   =   5;   
       tv.tv_usec   =   0;   //超时设置，超过5秒没有信息，就打印超时   
       while   (1)   
       {   
            FD_SET(fd,   &set);   
            if   ((i   =   select(fd   +   1,   &set,   NULL,   NULL,   &tv))   >   0)//检测管道是否信息   
            {   
                printf("receive   data/n");   
                if   (FD_ISSET(fd,   &set))   
                {   
                                len   =   read(fd,   buf,   MAXLINE);//读取信息   
                                buf[len]   =   ‘/0‘;   
                                printf("buf   =   %s/n",   buf);   
                                tv.tv_sec   =   atoi(buf);   
                                tv.tv_usec   =   0;   
                }   
            }   
            else   if   (i   ==   0)   
            {   
                 tv.tv_sec   =   5;   
                 tv.tv_usec   =   0;   
                 printf("chaoshi/n");   
            }   
            else   
                 printf("error/n");   
       }   
    
       unlink(FIFO);     //删除有名管道   
       return(0);   
  }  

发消息：

  #include                 <stdio.h>   
  #include                 <sys/types.h>   
  #include                 <sys/stat.h>   
  #include                 <string.h>   
  #include                 <fcntl.h>   
  #include                 <errno.h>   
    
  #define   FIFO         "/tmp/fifo.temp1"   
  #define   MAXLINE   1024   
    
  int   main(void)   
  {   
        int           fifo;   
        char         buf[MAXLINE];   
        int           len;   
        int           i   =   0;   
    
        strcpy(buf,   "10");   
        if   ((fifo   =   open(FIFO,   O_RDWR))   <   0)                   //读写打开有名管道   
        {   
             printf("mkfifo   error:   %s/n",   strerror(errno));   
             return(0);   
        }   
        while   (i   <   10)   
        {   
             sprintf(buf,   "%d",   i   +   1);   
             len   =   write(fifo,   buf,   strlen(buf));       //写入信息到管道中   
             printf("send   len   =   %d/n",   len);   
             sleep(i);   
             i++;   
        }   
    
        return(0);   
  }   

信号

信号是Unix/Linux系统在一定条件下生成的事件。信号是一种异步通信机制，进程不需要执行任何操作来等待信号的到达。信号异步通知接收信号的进程发生了某个事件，然后操作系统将会中断接收到信号的进程的执行，转而去执行相应的信号处理程序。

(1)注册信号处理函数
    #include <signal.h>
    /*typedef void (*sighandler_t)(int);  sighandler_t signal(int signum,sighandler_t handler);*/
    * void (*signal(int signum, void (*handler)(int)))(int);  //SIG_IGN && SIG_DFL
    * int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);

(2)发送信号
    #include <signal.h>
    * int kill(pid_t pid,int sig); //#include <sys/types.h> 
    * int raise(int sig);            //kill(getpid(),sig);
    * unsigned int alarm(unsigned int seconds); //(#include <unistd.h>) seconds秒后，向进程本身发送SIGALRM信号。

(3)信号集
    信号集被定义为:typedef struct {unsigned long sig[_NSIG_WORDS];} sigset_t;
    * int sigaddset(sigset_t *set,int sig);
    * int sigemptyset(sigset_t *set);

信号是进程间通信机制中唯一的异步通信机制，可以看作是异步通知，通知接收信号的进程有哪些事情发生了。信号机制经过POSIX实时扩展后，功能更加强大，除了基本通知功能外，还可以传递附加信息。

代码实例：

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

void int_handler(int signum)
{
 printf("\nSIGINT signal handler.\n");
 printf("exit.\n");
 exit(-1);
}

int main()
{
 signal(SIGINT, int_handler);
 printf("int_handler set for SIGINT\n");

 while(1)
 {
  printf("go to sleep.\n");
  sleep(60);
 }

 return 0;
}

消息队列

消息队列是内核地址空间中的内部链表，通过linux内核在各个进程直接传递内容，消息顺序地发送到消息队列中，并以几种不同的方式从队列中获得，每个消息队列可以用IPC标识符唯一地进行识别。内核中的消息队列是通过IPC的标识符来区别，不同的消息队列直接是相互独立的。每个消息队列中的消息，又构成一个独立的链表。
消息队列克服了信号承载信息量少，管道只能承载无格式字符流。

消息队列保存在内核中，是一个由消息组成的链表。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
(1)创建或访问消息队列
* int msgget(key_t key,int msgflg);

(2)操作消息队列
    * int msgsnd(int msqid,const void *msg,size_t nbytes,int msgflg);
msg指向的结构体必须以一个long int成员开头，作为msgrcv()的消息类型，必须大于0。nbytes指的是msg指向结构体的大小，但不包括long int部分的大小
    * ssize_t msgrcv(int msqid,void *msg,size_t nbytes,long msgtype,int msgflg);
如果msgtype是0，就返回消息队列中的第一个消息;如果是正整数，就返回队列中的第一个该类型的消息;如果是负数，就返回队列中具有最小值的第一个消息，并且该最小值要小于等于msgtype的绝对值。

(3)控制消息队列
    * int msgctl(int msqid,int cmd,struct msqid_ds *buf);
    * struct msqid_ds{
          struct ipc_perm msg_perm;
          …
       };

代码实例：

#include <sys/types.h>   
#include <sys/ipc.h>   
#include <sys/msg.h>   
#include <stdio.h>   
#define MAX_LINE 80   
#define MY_MQ_ID 1233   
/*消息结构体的一般形式如下：  
  typedef struct  
  {  
    long type;   //用于存放消息代码，必须位于首位  
    char message[ LENGHT+1 ];  
  }MSG_TYPE_T;  
 */  
typedef struct  
{   
    long type;     
    float fval;   
    unsigned int uival;   
    char strval[ MAX_LINE+1 ];   
}MY_TYPE_T;   
int main(  )   
    {   
        int msgid,ret;   
        //create the message queue with the id MY_MQ_ID   
        msgid=msgget( MY_MQ_ID,0666|IPC_CREAT );   
        if( msgid>=0 )   
             printf( "Created a Message Queue,message queue identifier is %d\n",msgid );   
        //modify the size of message queue   
        struct msqid_ds buf;   
        ret=msgctl( msgid,IPC_STAT,&buf );   
        printf( "The origianl size of queue is %d\n",buf.msg_qbytes );   
           
        buf.msg_qbytes=4096;   
        ret=msgctl( msgid,IPC_SET,&buf );   
        if( ret==0 )   
            printf( "Size sucessfully changed for queue,message queue identifier is %d\n",msgid );   
        //send a message   
        MY_TYPE_T myMessage;   
        myMessage.type=1L;   //消息的类型,msgrcv会用到   
        myMessage.fval=128.256;   
        myMessage.uival=512;   
        strncpy( myMessage.strval,"This is a test.\n",MAX_LINE );   
        ret=msgsnd( msgid,( struct msgbuf* )&myMessage,sizeof( MY_TYPE_T ),0 ); //0是消息旗标   
        if( ret!=-1 )   
            printf( "Message send successfully.\n" );   
        //read a message   
        MY_TYPE_T recMessage;   
        ret=msgrcv( msgid,( struct msgbuf* )&recMessage,sizeof(MY_TYPE_T),1,0 );//这个地方Message Type要和欲接受的消息类型相同   
        if( ret!=-1 )   
            {   
                printf( "\nRead a message from the queue\n" );   
                printf( "Message Type:%ld\n",recMessage.type );   
                printf( "Float value:%f\n",recMessage.fval );   
                printf( "Uint value:%d\n",recMessage.uival );   
                printf( "String value:%s\n",recMessage.strval );   
            }   
        //destroy a message queue   
        ret=msgctl( msgid,IPC_RMID,NULL );   
        if( ret!=-1 )   
            printf( "Message queue %d sucessfully removed.\n",msgid );   
           
        return 0;   
    }