Linux内核进程通信|酷客网

文章目录

1 popen与pclose
2 多进程与多线程
3 XSI消息队列
4 msg、sem和shm
5 msgrcv函数和msgsnd函数
6 msgctl函数
7 信号量(semget)
8 共享存储 shmget

进程通信(IPC)分为PIPE(管道)、Socket(套接字)和XSI(System_V)。XSI又分为msg(消息队列)、sem(信号量数组)和shm(共享内存)。这些手段都是用于进程间通信的，只有进程间通讯才需要借助第三方机制，线程之间通讯是不需要借助第三方机制，因为线程之间的地址空间是共享的。线程之间可以通过互斥量，死锁，唤醒，信号等来进行通讯。

popen与pclose

popen和pclose提供了原子操作，创建一个管道，fork一个子进程，关闭未使用的管道端，执行一个个shell运行命令，然后等待命令终止

#include <stdio.h>
FILE *popen(const char *cmdstring,const char *type);
// 成功返回文件指针，出错，返回NULL
int pclose(FILE *fp);

popen先执行fork，然后调用exec执行cmdstring，并且返回一个标准IO文件指针。如果type是”r”，则文件指针连接到cmdstring的标准输出；如果是”w”，则文件指针连接到cmfstring的标准输入

Linux内核进程通信

由图可以看出，stdout和stdin是较于子进程而言的。

pclose关闭标准IO流，等待命令终止，返回shell的终止状态。如果shell不能被执行，则pclose返回的终止状态与shell已执行exit一样。

    cmdstring
    fp = popen("ls *.c","r")
    fp = popen("cmd 2>&1","r")

多进程与多线程

多线程使用的基本是POSIZ标准提供的接口函数，而多进程则是基于System V。在信号量这种常用的同步互斥手段方面，POSIX在无竞争条件下是不会陷入内核的，而SystemV即无论何时都会陷入内核。这就给多线程每次调用都会陷入内核，丧失了线程的清亮优势。所以多线程之间的通信不是用System V。

ipcs命令可以查看CSI IPC的使用情况
ipcrm 命令可以删除指定的XSI IPC

通过查看ipcs

IPC status from <running system> as of Fri Feb 15 10:31:54 CST 2019T     ID     KEY        MODE       OWNER    GROUP
Message Queues:

T     ID     KEY        MODE       OWNER    GROUP
Shared Memory:

T     ID     KEY        MODE       OWNER    GROUP
Semaphores:

第一部分是消息队列，第二部分是共享内存，第三部分是信号量数组

每一列都有一列叫做”key”，使用XSI IPC通信的进程就是通过同一个key值操作同一个共享资源的。key是一个正整数，与文件描述符不同的是，生成一个新key值时，不采用当前可用的数值的最小值，而是类似生成进程ID的方式，key的值连续➕1，直到达到一个整数的最大正值，然后回转到0从头开始累加。

XSI消息队列

让通信双方传送结构体数据，提高传送数据灵活性

通信，就需要在通信之前双方约定通信协议，协议就是通信双方约定的数据交换格式。

从消息队列开始一直到Socket，都会看到类似的程序架构，无论是消息队列还是Socket，都需要约定通信协议，而且都是按照一定的步骤才能实现通讯。

消息队列在约定协议的时候，需要自定义结构体里要强制添加一个long mtype成员这个成员的作用是用于区分多种消息类型中的不同类型的数据包，当只有一种类型的包时这个成员没什么作用，但是也要一定必须带上。

既然时通讯也要区分主动端(先发包的一方) 和被动端(先收包的一方，先运行)，它们运行的时机不同，作用不同甚至调用函数也不同，所以我们的后面的每个例子几乎都要编译处2个不同的可执行程序来测试。

msg、sem和shm

xxxget() // 创建
xxxop() // 相关操作
xxxctl() // 其他的控制或销毁

msgget - get a Syatem V message queue identifier

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int msgget(key_t key,int msgflg);

msgget函数的作用是创建一个消息队列，消息读列是双工的，两边都可以读写。

key相当于通信双方的街头暗号，拥有相同key的双方才可以通信

key值必须是唯一的，系统中有个ftok函数可以用于获取key，通过文件inode和salt进行hash运算来生成唯一的key，只要两个进程使用相同的文件和salt就可以生成一样的key值了。

msgflg: 特殊要求。无论有多少特殊要求，只要使用了IPC_CREAT，就必须按位或一个权限，权限不是想指定多大就能多大，要用它&=~umask。

同一个消息队列只需要创建一次，所以谁先运行起来谁有责任创建消息队列，后运行起来的就不需要创建了。

同理，对于后启动的进程来说，消息队列不是他创建的，就没必要销毁了。

msgrcv函数和msgsnd函数

msgrcv函数和msgsnd函数, 从msgid这个消息队列中接收数据

msgrcv,msgsnd - message operations
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int msgsnd(int msgid, const void *msgp,size_t msgsz,int msgflg);

ssize_t msgrcv(int msgid,void *msgp,size_t msgsz,long msgtyp,int msgflg);
// msgp成员的定义要类似msgbuf这个结构体，第一成员必须是long类型的mtype，并且必须是>0的值
struct msgbuf{
    long mtype; // 消息类型 必须>0
    char mtext[1]; // 消息数据字段
};

msgrcv函数从msgid这个消息队列中接收数据，并将接收到的数据放到msgp结构体中，这段空间有msgsz这个字节的大小，msgsz的值要减掉强制的成员mtype的大小(sizeof(long))。
msgtyp是msgp结构体中的mtype的成员，表示需要接收那种类型的消息。虽然msg是消息队列，但是它并不完全遵循队列的形式，可以让接收者挑消息接收。如果不挑消息可以填写0，这样就按照队列中的消息顺序返回。
msgflg是特殊要求位图，没有写0
msgsnd函数向msgid这个消息队列发送msgp结构体数据，msgp的大小是msgsz，msgflg是特殊要求没有写0。

msgctl函数

msgctl函数 跟iocrtl、fcntl函数用法类似

msgctl - message control operations
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int msgctl(int msgid,int cmd,struct msqid_ds *buf);
// 通过cmd指定具体命令，然后通过buf为cmd命令设定参数，当然有些命令是需要参数的，有些命令则不需要参数

最常用的cmd就是IPC_RMID，表示删除(结束)某个IPC通信，并且这个命令不需要buf参数，直接传入NULL即可。

buf结构体里面的成员很多。

/***
 * 共同的协议proto.h
 * ***/
/*定义双方都需要使用的数据或对象*/
#ifndef PROTO_H__
#define PROTO_H__
#define NAMESIZE 32
// 通讯双方生成key值共同使用的文件
#define KEYPATH "./test.txt"
// 通讯双方生成key值共同使用的salt值
#define KEYPROJ 'a'

// 消息类型，只要是大于0的合法整数即可
#define MSGTYPE 10

// 通讯双方约定的协议
struct msg_st{
    long mtype;
    char name[NAMESIZE];
    int math;
    int chinese;
};
#endif //  PROTO_H__

接收端要先运行，先创建接收端的消息队列

#include "../include/apue.h"
#include <sys/ipc.h>
#include <sys/msg.h>

#include "proto.h"

int main(void){
    key_t key;
    int msgid;
    struct msg_st rbuf;

    // 通过/tmp/out文件和字符'a'生成唯一的key，文件必须真实存在
    key = ftok(KEYPATH,KEYPROJ); // 来自proto.h
    if(key<0) err_sys("ftok()");

    // 接收端先启动，所以消息队列由接收端创建
    if((msgid = msgget(key,IPC_CREAT|0600))<0) err_sys("msgget");

    // 不停的接收消息 轮询
    while(1){
        // 没有消息就会阻塞等待
        if(msgrcv(msgid,&rbuf,sizeof(rbuf)-sizeof(long),0,0)<0) err_sys("msgrcv");

        /***
         * 用结构体中强制添加的成员判断消息类型
         * 当然这个栗子只有一种消息类型，所以不判断也可以
         * 如果包含多种消息类型就可以协议组switch ...case结构
         * ***/
        if(rbuf.mtype == MSGTYPE){
            printf("Name = %s\n",rbuf.name);
            printf("Math = %d\n",rbuf.math);
            printf("Chinese = %d\n",rbuf.chinese);

        }
    }
    /***
     * 谁创建谁销毁
     * 这个程序无法正常结束只能等信号杀死
     * 使用信号杀死之后可以用ipcs命令查看，消息队列应该没有被销毁
     * 使用ipcrm删掉
     * ***/
    msgctl(msgid,IPC_RMID,NULL); // 销毁
    exit(0);
}

发送端

#include "../include/apue.h"
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <time.h>

#include "proto.h"

int main(){
    key_t key;
    int msgid;
    struct msg_st sbuf;

    // 设置随机数种子
    srand(time(NULL));
    // 用于接收方相同的文件和salt生成一样的key
    key = ftok(KEYPATH,KEYPROJ);
    if(key<0) err_sys("ftok()");
    // 取得消息队列
    msgid = msgget(key,0);
    if(msgid<0) err_sys("msgget");

    // 要发送的结构体赋值
    sbuf.mtype = MSGTYPE;
    strcpy(sbuf.name,"Trans");
    sbuf.math = rand()%100;
    sbuf.chinese = rand()%100;

    if(msgsnd(msgid,&sbuf,sizeof(sbuf)-sizeof(long),0)<0) err_sys("msgsnd");

    puts("ok!");
    exit(0);
}

最后使用ipcs查看，消息队列显式

IPC status from <running system> as of Fri Feb 15 12:21:02 CST 2019
T     ID     KEY        MODE       OWNER    GROUP
Message Queues:
q  65536 0x6104a0ae --rw------- transcheung    staff

T     ID     KEY        MODE       OWNER    GROUP
Shared Memory:

T     ID     KEY        MODE       OWNER    GROUP
Semaphores:

KEYPROJ直接充当salt值，接收方先运行，所以接收方先创建消息队列，发送方要使用相同的文件和salt生成于接收方相同的key值，这样才能使用同一个消息队列。

发送方发送一个结构体，接收方接收结构体并解析打印，所以这个结构体保证了数据能够正常被解析，所以这个结构体就是我们所说的”协议”。所以协议就是要保证一样的，所以写了一个proto.h文件，让发送方共同引用，就保证是相同的结构体了。

信号量(semget)

信号量(semget) 按部就班，步骤与消息队列差不多

semget - get a semaphore set identifier
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semget(key_t key,int nsems,int semflg);
// 用于创建信号量，成功返回sem ID，失败返回-1并设置errnp

key: 具有亲缘关系的进程之间可以使用一个匿名的key值，key使用宏IPC_PRIVATE即可
nsems:表示你到底有多少个sem。信号量其实是一个计数器，如果设置为1可以用来模拟互斥量
semflg:IPC_CREAT表示创建sem，同时需要按位或一个权限，如果是匿名IPC则无需执行这个宏，直接给权限就好

semctl - semaphore control operations

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semctl(int semid, int semnum, int cmd, ...);
// 用来控制或销毁信号量

semnum:信号量数组下标
cmd: 可选的宏。常用的由IPC_RMID，表示从系统中删除该信号量集合，SETVAL可以为第几个成员设置值。
…: 根据不同命令设置不同的参数，后面的参数是变长的

semop - semaphore operations

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semop(int semid, struct sembuf *sops, unsigned nsops);
// 操作信号量。由于多个信号量可以组成数组。sops参数是数组的起始位置，nspos是指定数组的长度
// 成功返回0，失败返回-1并设置errno
struct sembuf {
    unsigned short sem_num; /* 对第几个资源（数组下标）操作 */
    short sem_op; /* 取几个资源写负数几(不要写减等于)，归还几个资源就写正数几 */
    short sem_flg; /* 特殊要求 */
};

信号量实际上是一个计数器，所以每次在使用资源之前，我们需要扣减信号量，当信号量被减到0时会阻塞等待。每次使用完成资源后，归还信号量，也就是增加信号量的数值

通过操作信号量的函数实现一个通过信号量实现互斥量的例子

#include "../include/apue.h"
#include <string.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <errno.h>

#define PROCNUM 20
#define FNAME "./test.txt"
#define BUFSIZE 1024

// 多个函数都要使用这个信号量ID，所以定义为全局变量
static int semid;

// P操作
static void P(void){
    struct sembuf op;
    op.sem_num = 0; // 只有一个资源所以数组下标是0
    op.sem_op = -1; // 取一个资源就减1
    op.sem_flg = 0; // 没有特殊要求
    while(semop(semid,&op,1)<0){
        if(errno != EINTR && errno!=EAGAIN) err_sys("semop()");
    }
}
// V操作
static void V(void){
    struct sembuf op;
    op.sem_num = 0;
    op.sem_op = 1;
    op.sem_flg = 0;
    while(semop(semid,&op,1)<0){
        if(errno != EINTR && errno != EAGAIN) err_sys("semop()");
    }
}

static void func_add(){
    FILE *fp;
    char buf[BUFSIZE];
    fp = fopen(FNAME,"r+");
    if(fp == NULL) err_sys("fopen()");
    // 先取得信号量再操作文件，取不到就阻塞等待，避免发生竞争
    P();
    fgets(buf,BUFSIZE,fp); // 获取一行字符串
    rewind(fp); // 从头指针开始
    sleep(1); // 放大竞争
    fprintf(fp,"%d\n",atoi(buf)+1);
    fflush(fp);
    // 操作结束，归还信号量，让其他进程可以取得信号量
    V();
    fclose(fp);
    return;
}

int main(){
    int i;
    pid_t pid;

    // 在具有亲缘关系的进程之间使用，所以设置为IPC_PRIVATE
    // 另外想要实现互斥量的效果，所以信号量数量设置为1个即可
    semid = semget(IPC_PRIVATE,1,0600);
    if(semid<0) err_sys("semget()");
    // 将union semun.val的值设置为1
    if(semctl(semid,0,SETVAL,1)<0) err_sys("semctl()");

    // 创建20个子进程
    for(i = 0;i<PROCNUM;i++){
        pid = fork();
        if(pid<0) err_sys("fork()");
        if(pid == 0){
            func_add();
            exit(0);
        }
    }

    for(i = 0;i<PROCNUM;i++) wait(NULL);

    // 销毁信号量
    semctl(semid,0,IPC_RMID);
    exit(0);
}

共享存储 shmget

XSI的共享内存，一样按命名规则来

shmget - allocates a shared memory segment
#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key,size_t size,int shmflg);
// 成功返回shm ID；失败，返回-1

key: 共享内存的唯一标识，具有亲缘关系的进程之间使用共享内存可以使用IPC_PRIVATE宏代替
size: 是共享内存大小
shmflg: IPC_CREAT表示创建shm，同时需要按位或一个权限，如果是=匿名IPC就无须指定这个宏，直接给权限就好

shmat - shared memory operations

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

void *shmat(int shmid, const void *shmaddr, int shmflg);
int shmdt(const void *shmaddr);

shmat使进程与共享内存关联起来。shmat函数中的shmaddr参数是共享内存的起始地址，传入NULL由内核帮我们寻找合适的地址。一般情况我们都是传入NULL值。

shmdt函数用于使进程分离共享内存，共享内存使用完毕之后需要用这个函数分离。分离不代表释放了这块空间，使用共享内存的双方依然要遵守”谁申请，谁释放“的原则。没有申请的一方是不需要释放的，但是双方都需要分离。

shmctl - shared memory control
#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid,int cmd,struct shmid_ds *buf);
// 控制或删除共享内存

cmd设置IPC_RMID并且buf参数设置为NULL，就可以删除共享内存

#include "../include/apue.h"
#include <sys/mman.h>
#include <fcntl.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/wait.h>

#define MEMSIZE 1024

int main(){
    char *str;
    pid_t pid;
    int shmid;
    // 有亲缘关系的进程key参数可以使用IPC_PRIVATE宏，并且创建共享内存
    // shmflg参数不需要使用IPC_CREAT宏
    shmid = shmget(IPC_PRIVATE,MEMSIZE,0600);
    if(shmid < 0) err_sys("shmget()");
    if((pid = fork())<0) err_sys("fork()");
    if(pid==0){// 子进程
        // 关联共享内存
        str = shmat(shmid,NULL,0);
        if(str == (void*)-1) err_sys("shmat()");
        // 向共享内存写入数据
        strcpy(str,"hello!");
        // 分离共享内存
        shmdt(str);
        // 无需释放
        exit(0);
    }else{
        // 等待子进程结束后再运行，需要读取子进程写入的共享内存的数据
        wait(NULL);
        // 关联共享内存
        str = shmat(shmid,NULL,0);
        if(str == (void *)-1) err_sys("shmat()");
        // 打印读出来的数据
        puts(str);
        // 分离共享内存
        shmdt(str);
        // 释放共享内存 回收寺院
        shmctl(shmid,IPC_RMID,NULL);
        exit(0);
    }
    exit(0);

}

酷客网相关文章：

Linux内核进程通信

popen与pclose

多进程与多线程

XSI消息队列

msg、sem和shm

msgrcv函数和msgsnd函数

msgctl函数

信号量(semget)

共享存储 shmget

相关推荐

评论抢沙发

评论前必须登录！

Linux Kernel参考资料

回顶部

popen与pclose

多进程与多线程

XSI消息队列

msg、sem和shm

msgrcv函数和msgsnd函数

msgctl函数

信号量(semget)

共享存储 shmget

相关推荐

评论 抢沙发

评论前必须登录！

Linux Kernel参考资料

回顶部

评论抢沙发