Linux&C———进程间通信

• 管道和有名管道
• 消息队列
• 共享内存
• 信号
• 套接字

由于进程之间的并不会像线程那样共享地址空间和数据空间,所以进程之间就必须有自己特有的通信方式,这篇博客主要介绍自己了解到的几种进程之间的通信方式,内容讲的比较浅,目的相当于做学习笔记.
一:管道和有名管道
管道是一种半双工的通信方式(即数据只能单方面流动),TCP协议提供的就是一种全双工的通信方式,并且管道只能在具有亲缘关系的进程之间通信,例如父子进程,兄弟进程.有名管道与管道不同点在于

1:有名管道支持所有进程之间的通信.
2:有名管道在操作上和文件相似,较管道而言,操作更加方便.
3:管道存在与内存之中,但是有名管道存在与磁盘上,是文件.

下面介绍几个主要的函数

int pipefd[2];
int pipe(int pipefd[2]);
pipe()函数用来创建管道,返回的两个文件描述符,fd[0]:读文件描述符,fd[1]:写文件描述符,用来进行信息交流.一般文件进行操作的I/O函数也适用于管道.

注意点:
1:如果进程希望向管道中写数据,那么必须关闭fd[0]文件描述符,同时管道的另一端关闭fd[1]文件描述符
2:只有当管道的读端存在时,写才有意义,否则,向管道中写入数据的进程将收到来自内核的信号,write出错.

void read_from_pipe(int fd)                //定义读函数
{
    char message[100];
    read(fd,message,100);
    printf("read from pipe:%s",message);
}
void write_to_pipe(int fd)                 //定义写函数
{
    char *message = "hello world\n";
    write(fd,message,strlen(message)+1);
}
int main(int argc,char *argv[])
{
    int    fd[2];
    pid_t  pid;
    int    stat_val;
    if(pipe(fd) != 0)                      //创建管道
    {
        my_err("pipe",__LINE__);
    }
    pid = fork();                          //创建进程
    switch(pid)
    {
        case -1:
        {
            my_err("fork error",__LINE__);
        }
        case 0:
        {
            close(fd[1]);                  //关闭子进程的写端
            read_from_pipe(fd[0]);         //从读端去读
            exit(0);
        }
        default:
        {
            close(fd[0]);                  //关闭读端
            write_to_pipe(fd[1]);          //写入
            wait(&stat_val);
            exit(0);
        }
    }
    return 0;
}

我们经常会在fork一个子进程后让它去执行exec系列函数,但是此时子进程不会继承父进程的文件描述符,这使得我们无法使用管道,为了避免这个问题,我们可以先将文件描述符调用dup或者dup2复制到标准输入或者别的地方,之后我们再对另一个文件描述符操作,达到我们进程管道之间通信的目的.
下面我们继续讨论有名管道:

int mknod(const char *pathname, mode_t mode, dev_t dev);
pathname:管道名 mode :管道的权限,”S_IFIFO|0666”表示建立一个有名管道并且存取权限为0666,dev默认为0;
int mkfifo(const char *pathname, mode_t mode);
参数与mknod前两个参数一致
有名管道的使用方法与管道相似,但是由于它是一个设备,所以必须在调用之前利用open 打开.但是它的打开方式如果不是以可读可写的方式,那么将会阻塞,即如果以只读打开,则调用open的进程将会被阻塞,直到有写.

二:消息队列
消息队列是一个存放在内核中的链表,每个消息队列都由消息队列表示符标识,与管道不同,消息队列存放在内核之中,我们可以调用msgctl函数来删除一个消息队列,或者将内核重启也可以删除消息队列.
1:熟悉有关的几个数据结构

struct msgbuf : 消息缓冲机构
struct msqid_ds : 每个消息队列都会维护这样一个结构体,里面是此消息队列的具体信息.
struct ipc_perm : 它是msqid_ds的一个成员,里面主要包含消息队列的一些重要信息,比如key,用户ID,组ID等

2:消息队列的创建与读写及获取和设置相关属性.

key_t key;
int msqid;
struct msgbuf
key = ftok(const char *pathname, int proj_id); //用来获取一个键值,
msqid = msgget(key_t key, int msgflg); //获取文件描述符
初始化结构体msgbuf的信息
msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); //写一个消息到消息队列
msgrcv(int msqid, void *msgp, size_t msgsz, long msgtype,int msgflg); //从消息队列中读取一个消息.
msgctl(int msqid, int cmd, struct msqid_ds *buf); //用来获取或者设置消息队列
cmd:IPC_CREAT:用来获取消息队列对应的msqid_ds数据结构,将其保存到buf指向的数据空间
IPC_SET:设置属性,将要设置的属性存储在buf里
IPC_RMID:从内核删除qid的消息队列

下面附上一段代码:

void my_err(char *err_string,int line)
{
    fprintf(stderr,"line : %d",line);
    perror("err_string");
    exit(0);
}
void getmsgattr(int msgqid,struct msqid_ds msq_info)
{
    if(msgctl(msgqid,IPC_STAT,&msq_info) == -1)
        my_err("msgctl",__LINE__);
    printf("\ninformation of message queue\n");
    printf("last message time is %s\n",ctime(&(msq_info.msg_stime)));
    printf("msg uid is %d\n",msq_info.msg_perm.uid);
}
int main(int argc,char *argv[])
{
    struct mymsgself
    {
        long  msgtype;
        char ctrlstring[1024];
    }msgbuffer;
    key_t   key;
    int     msgqid;
    int     msglen;
    struct  msqid_ds msq_attr;
    if((key = ftok(".",32)) == -1)                  //创建key值
        my_err("ftok",__LINE__);
    if((msgqid = msgget(key,IPC_CREAT|0660)) == -1) //返回msgqid
        my_err("msgget",__LINE__);
    getmsgattr(msgqid,msq_attr);                    //获取属性
    msgbuffer.msgtype = 1;
    strcpy(msgbuffer.ctrlstring,"hello i am yang");
    msglen = sizeof(struct mymsgself) - 4;
    if(msgsnd(msgqid,&msgbuffer,msglen,0) == -1)    //放松一个消息到消息队列
        my_err("msgsnd",__LINE__);
    getmsgattr(msgqid,msq_attr);                    //再次查看属性
    if(msgrcv(msgqid,&msgbuffer,msglen,1,0) == -1)  //读出来消息
        my_err("msgrcv",__LINE__);
    printf("read from msgqueue : %s\n",msgbuffer.ctrlstring);
    getmsgattr(msgqid,msq_attr);
    sleep(10);                                      //sleep 10秒之后删除队列
    if(msgctl(msgqid,IPC_RMID,NULL) == -1)          //删除消息队列
        my_err("msgctl",__LINE__);
    return 0;
}

在程序执行过程我们可以调用ipcs命令查看内核的消息队列状态

$: watch -n 1 “ipcs”

三:共享内存
共享内存就是分配一块能被其他进程访问的内存,每个共享内存段在内核中维护着一个内部的结构struct shmid_ds(类似与消息队列和信号量).下面介绍共享内存的创建以及一些操作:

key_t key;
key = ftok(const char *pathname, int proj_id); //创建一个key值
shmid = shmget(key_t key, size_t size, int shmflg); //建立一块共享内存
void *shmat(int shmid, NULL, int shmflg); //将共享内存与进程建立连接,成功返回指向这块内存的指针,第二个参数默认设置为NULL.
int shmdt(const void *shmaddr); //将进程与共享内存断开连接,shmaddr是shmat的返回值.
int shmctl(int shmid, int cmd, struct shmid_ds *buf); //cmd:IPC_RMID:从系统中删除这块共享内存,IPC_SET:设置shmid_ds结构, IPC_STAT,读取这块共享内存的shmid_ds结构,将其存储到buf指向的地址中.

四:信号
具体的基础知识在这篇博客中写过,可以参考:Linux&C—–信号以及信号处理
下面在举一个例子,让信号之间传递数据.

//send_data_signo.c
int main(int argc,char *argv[])
{
    union sigval value;
    int   signum = SIGTERM;          //默认结束进程的信号
    pid_t pid;
    int   i;
    value.sival_int = 0;             //初始化
    for(i = 1;i < argc;i++)          //解析各个参数
    {
        if(!strcmp(argv[i],"-d"))
        {
            value.sival_int = atoi(argv[i+1]);
            continue;
        }
        if(!strcmp(argv[i],"-s"))
        {
            signum = atoi(argv[i+1]);
            continue;
        }
        if(!strcmp(argv[i],"-p"))
        {
            pid = atoi(argv[i+1]);
            continue;
        }
    }   
    if(sigqueue(pid,signum,value) < 0) //利用sigqueue给pid发送信号,并且携带数据value
    {
        perror("sigqueue");
        exit(1);
    }
    return 0;
}

//recv_data_signo.c
void handler_sigint(int signo,siginfo_t *siginfo,void *pvoid)
{
    printf("recv SIGINT ,the data value is :%d\n",siginfo->si_int);
}
int main(int argc,char *argv[])
{
    struct sigaction act;
    act.sa_sigaction = handler_sigint;
    act.sa_flags = SA_SIGINFO;            //表明使用sigaction中第二个结构体中的sa_sigaction来设置参数
                                          //接收进程可以从siginfo_t 结构的si_value域取得信号发送时携带的数据
    sigaction(SIGINT,&act,NULL);          //捕捉ctrl+c
    while(1);
    return 0;
}

./recv_data_signo
ps -a
./send_data_signo -s 2 -d <要传输的数据> -p <进程ID>

从运行结果我们可以看出来-d 参数后面的数据确实被传递了过去.

五:套接字
有关套接字编程,具体见这一篇博客:三次握手”分析——以一个简单的“服务器”和“客户端”为例.其中服务器和客户端的代码每一步都有详细的注释.