Linux系统编程5.消息管理

Linux 下的进程通信(IPC)
POSIX 无名信号量
System V 信号量
System V 消息队列
System V 共享内存

1. POSIX无名信号量

PV操作是原子操作.也就是操作是不可以中断的,在一定的时间内,只能够有一个进程的代码在 CPU 上面执行.

在系统当中,有时候为了顺利的使用和保护共享资源,提出了信号的概念.

假设使用一台打印机,如果在同一时刻有两个进程在向打印机输出,那么最终的结果会肯定是混乱的.

为了处理这种情况,POSIX 标准提出了有名信号量和无名信号量的概念.

Linux 只实现了无名信号量

信号量的使用主要是用来保护共享资源,使的资源在一个时刻只有一个进程所拥有.为此可以使用一个信号灯.当信号灯的值为某个值的时候,就表明此时资源不可以使用.否则就表示可以使用.

POSIX 的无名信号量的函数有以下几个：
#include <semaphore.h>;
int sem_init(sem_t *sem,int pshared,unsigned int value);
/*创建一个信号灯,并初始化其值为 value.*/
/*pshared 决定了信号量能否在几个进程间共享，Linux 还没有实现进程间共享信号灯,所以这个值只能够取 0.*/
int sem_destroy(sem_t *sem);
/*删除信号灯*/
int sem_wait(sem_t *sem);
/*将阻塞进程,直到信号灯的值大于 0.这个函数返回的时候自动的将信号灯的值的-1*/
int sem_trywait(sem_t *sem);
/*不阻塞的,当信号灯的值为 0 的时候返回 EAGAIN,表示以后重试.*/
int sem_post(sem_t *sem);
/*将信号灯的内容+1同时发出信号，唤醒等待的进程.*/
int sem_getvalue(sem_t *sem);
/*得到信号值*/

这几个函数的使用相当简单的.比如有一个程序要向一个系统打印机打印两页.

首先创建一个信号灯,并使其初始值为 1,表示我们有一个资源可用.然后一个进程调用 sem_wait 由于这个时候信号灯的值为 1,所以这个函数返回,打印机开始打印了,同时信号灯的值为 0 了. 如果第二个进程要打印,调用 sem_wait 时候,由于信号灯的值为 0,资源不可用,于是被阻塞了.

当第一个进程打印完成以后,调用 sem_post，信号灯的值为 1 了,这个时候系统通知第二个进程,于是第二个进程的 sem_wait 返回.

第二个进程开始打印了.

可以使用线程来解决这个问题.

编译包含上面这几个函数的程序要加上 -lrt 选贤,以连接 librt.so 库。

2. System V信号量

System V 信号量的函数主要有下面几个.

#include <sys/types.h>;
#include <sys/ipc.h>;
#include <sys/sem.h>;
key_t ftok(char *pathname,char proj);
//根据 pathname 和 proj 来创建一个关键字.
int semget(key_t key,int nsems,int semflg);
// 创建一个信号量,成功时返回信号的 ID.
// key关键字,可以是ftok创建的或者IPC_PRIVATE表明由系统选用一个关键字. 
// nsems 表明创建的信号个数.
// semflg 是创建的权限标志,和创建文件的标志相同.
int semctl(int semid,int semnum,int cmd,union semun arg);
//对信号量进行一系列的控制.
//semid 是要操作的信号标志,semnum 是信号的个数,cmd 是操作的命令.经常用的两个值是： SETVAL(设置信号量的值)和 IPC_RMID(删除信号灯).arg 是一个给 cmd 的参数.
int semop(int semid,struct sembuf *spos,int nspos);
/*对信号进行操作的函数.
semid 是信号标志,
spos 是一个操作数组表明要进行什么操作,
nspos 表明数组的个数. 

如果 sem_op 大于 0,那么操作将 sem_op 加入到信号量的值中,并唤醒等待信号增加的进程. 

如果为 0,当信号量的值是 0 的时候,函数返回,否则阻塞直到信号量的值为 0. 

如果小于 0,函数判断信号量的值加上这个负值.

如果结果为 0 唤醒等待信号量为 0 的进程,
如果小于 0 函数阻塞.
如果大于 0,那么从信号量里面减去这个值并返回*/
struct sembuf {
    short sem_num; /* 使用那一个信号 */
    short sem_op; /* 进行什么操作 */
    short sem_flg; /* 操作的标志 */
};

实例：

#include <stdio.h>;
#include <unistd.h>;
#include <limits.h>;
#include <errno.h>;
#include <string.h>;
#include <stdlib.h>;
#include <sys/stat.h>;
#include <sys/wait.h>;
#include <sys/ipc.h>;
#include <sys/sem.h>;
#define PERMS S_IRUSR|S_IWUSR
void init_semaphore_struct(struct sembuf *sem,int semnum,
int semop,int semflg)
{
    /* 初始化信号灯结构 */
    sem->sem_num=semnum;//使用哪一个信号
    sem->sem_op=semop;//进行什么操作
    sem->sem_flg=semflg;//操作标志
}
int del_semaphore(int semid)
{
/* 信号灯并不随程序的结束而被删除,如果没删除的话(将 1 改为 0)
   可以用 ipcs 命令查看到信号灯,用 ipcrm 可以删除信号灯的
*/
#if 1
    return semctl(semid,0,IPC_RMID);
#endif
}
int main(int argc,char **argv)
{
    char buffer[MAX_CANON],*c;
    int i,n;
    int semid,semop_ret,status;
    pid_t childpid;
    struct sembuf semwait,semsignal;/*semop函数的参数*/
/*------------------错误处理----------------------------*/
    if((argc!=2)||((n=atoi(argv[1]))<1))/*参数错误or参数太短*/
    {
        fprintf(stderr,"Usage： %s number\n\a",argv[0]);
        exit(1);
    }
    /* 使用 IPC_PRIVATE 表示由系统选择一个关键字来创建 */
    /* 创建以后信号灯的初始值为 0 */
    if((semid=semget(IPC_PRIVATE,1,PERMS))==-1)
    //有系统选择一个关键字创建一个信号
    //创建信号灯出错
    {
        fprintf(stderr,"[%d]： Acess Semaphore Error： %s\n\a",
        getpid(),strerror(errno));
        exit(1);
    }
/*------------------正确处理----------------------------*/
    /* semwait 是要求资源的操作(-1) */
    init_semaphore_struct(&semwait,0,-1,0);
    /* semsignal 是释放资源的操作(+1) */
    init_semaphore_struct(&semsignal,0,1,0);
    /* 开始的时候有一个系统资源(一个标准错误输出) */
    if(semop(semid,&semsignal,1)==-1)
    //信号操作出错
    {
        fprintf(stderr,"[%d]： Increment Semaphore Error： %s\n\a",getpid(),strerror(errno));
        if(del_semaphore(semid)==-1)//删除信号灯出错
            fprintf(stderr,"[%d]： Destroy Semaphore Error： %s\n\a",getpid(),strerror(errno));
        exit(1);
    }
/* 创建一个进程链 */
    for(i=0;i<n;i++)
        if(childpid=fork()) 
            break;
    sprintf(buffer,"[i=%d]-->[Process=%d]-->[Parent=%d]-->[Child=%d]\n",i,getpid(),getppid(),childpid);
    c=buffer;
/* 这里要求资源,进入原子操作 */
    while(((semop_ret=semop(semid,&semwait,1))==-1)&&(errno==EINTR));
    if(semop_ret==-1)
    {
        fprintf(stderr,"[%d]： 申请资源错误： %s\n\a",getpid(),strerror(errno));
    }
    else
    {
        fprintf(info,"[%d]： 申请资源成功： %s\n\a",
        getpid());
        while(*c!='\0')fputc(*c++,stderr);
        /* 原子操作完成,赶快释放资源 */
        while(((semop_ret=semop(semid,&semsignal,1))==-1)&&(errno==EINTR));
        if(semop_ret==-1)
        fprintf(stderr,"[%d]： 释放资源错误： %s\n\a",
        getpid(),strerror(errno));
    }
    /* 不能够在其他进程反问信号灯的时候,删除信号灯 */
    while((wait(&status)==-1)&&(errno==EINTR));
    /* 信号灯只能够被删除一次的 */
    if(i==1)
        if(del_semaphore(semid)==-1)
            fprintf(stderr,"[%d]： Destroy Semaphore Error： %s\n\a",getpid(),strerror(errno));
    exit(0);
}
信号灯的主要用途是保护临界资源(在一个时刻只被一个进程所拥有)

3. SystemV 消息队列

为了便于进程之间通信,可以使用管道通信；SystemV 也提供了一些函数来实现进程的通信.这就是消息队列。

#include <sys/types.h>; 
#include <sys/ipc.h>;
#include <sys/msg.h>;
int msgget(key_t key,int msgflg);
//msgget 函数和 semget 一样,返回一个消息队列的标志

int msgsnd(int msgid,struct msgbuf *msgp,int msgsz,int msgflg);
int msgrcv(int msgid,struct msgbuf *msgp,int msgsz,
long msgtype,int msgflg);
//msgsnd 和 msgrcv 函数是用来进行消息通讯的

int msgctl(Int msgid,int cmd,struct msqid_ds *buf);
//msgctl 和 semctl 是对消息进行控制
struct msgbuf {
    long msgtype; /* 消息类型 */
    ....... /* 其他数据类型 */
}

msgid 是接受或者发送的消息队列标志.
msgp 是接受或者发送的内容.
msgsz 是消息的大小.
结构 msgbuf 包含的内容是至少有一个为 msgtype.
其他的成分是用户定义的.

对于发送函数 msgflg 指出缓冲区用完时候的操作.
接受函数指出无消息时候的处理.一般为 0.
接收函数 msgtype 指出接收消息时候的操作.

如果 msgtype=0,接收消息队列的第一个消息.
大于 0 接收队列中消息类型等于这个值的第一个消息.
小于 0 接收消息队列中小于或者等msgtype 绝对值的所有消息中的最小一个消息.

我们以一个实例来解释进程通信.下面这个程序有 server 和 client 组成.先运行服务端后运行客户端.
服务端 server.c

#include <stdio.h>;
#include <string.h>;
#include <stdlib.h>;
#include <errno.h>;
#include <unistd.h>;
#include <sys/types.h>;
#include <sys/ipc.h>;
#include <sys/stat.h>;
#include <sys/msg.h>;
#define MSG_FILE "server.c" //中间介质
#define BUFFER 255
#define PERM S_IRUSR|S_IWUSR
struct msgtype {
    long mtype;
    char buffer[BUFFER+1];
};
int main()
{
    struct msgtype msg;
    key_t key;
    int msgid;
    if((key=ftok(MSG_FILE,'a'))==-1)
    {
        fprintf(stderr,"Creat Key Error： %s\a\n",strerror(errno));
        exit(1);
    }
    if((msgid=msgget(key,PERM|IPC_CREAT|IPC_EXCL))==-1)
    {//和semget一样返回一个msgid
        fprintf(stderr,"Creat Message Error： %s\a\n",strerror(errno));
        exit(1);
    }
    while(1)
    {
        msgrcv(msgid,&msg,sizeof(struct msgtype),1,0);
        fprintf(stderr,"Server Receive： %s\n",msg.buffer);
        msg.mtype=2;
        msgsnd(msgid,&msg,sizeof(struct msgtype),0);
    }
    exit(0);
}

客户端(client.c)

#include <stdio.h>;
#include <string.h>;
#include <stdlib.h>;
#include <errno.h>;
#include <sys/types.h>;
#include <sys/ipc.h>;
#include <sys/msg.h>;
#include <sys/stat.h>;
#define MSG_FILE "server.c" //通信介质
#define BUFFER 255
#define PERM S_IRUSR|S_IWUSR

struct msgtype {
    long mtype;
    char buffer[BUFFER+1];
};
int main(int argc,char **argv)
{
    struct msgtype msg;
    key_t key;
    int msgid;
    if(argc!=2)
    {
        fprintf(stderr,"Usage： %s string\n\a",argv[0]);
        exit(1);
    }
    if((key=ftok(MSG_FILE,'a'))==-1)
    {
        fprintf(stderr,"Creat Key Error： %s\a\n",strerror(errno));
        exit(1);
    }
    if((msgid=msgget(key,PERM))==-1)
    {
        fprintf(stderr,"Creat Message Error：%s\a\n",strerror(errno));
        exit(1);
    }
    msg.mtype=1;
    strncpy(msg.buffer,argv[1],BUFFER);
    msgsnd(msgid,&msg,sizeof(struct msgtype),0);
    memset(&msg,'\0',sizeof(struct msgtype));
    msgrcv(msgid,&msg,sizeof(struct msgtype),2,0);
    fprintf(stderr,"Client receive： %s\n",msg.buffer);
    exit(0);
}
//注意服务端创建的消息队列最后没有删除,我们要使用 ipcrm 命令来删除的.

4. 共享内存

一个进程通信的方法是使用共享内存.SystemV 提供了以下几个函数以实现共享内存

#include <sys/types.h>;
#include <sys/ipc.h>;
#include <sys/shm.h>;
int shmget(key_t key,int size,int shmflg);
/*size大小，shmflg只要用0代替就可以*/
void *shmat(int shmid,const void *shmaddr,int shmflg);
/*用来连接共享内存的*/
int shmdt(const void *shmaddr);
/*断开共享内存*/
int shmctl(int shmid,int cmd,struct shmid_ds *buf);

在使用一个共享内存之前调用 shmat 得到共享内存的开始地址,使用结束以后使用 shmdt 断开这个内存.

实例：

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#define PERM S_IRUSR|S_IWUSR
int main(int argc,char **argv)
{
    int shmid;
    char *p_addr,*c_addr;
    if(argc!=2)
    {
        fprintf(stderr,"Usage： %s\n\a",argv[0]);
        exit(1);
    }
    if((shmid=shmget(IPC_PRIVATE,1024,PERM))==-1)
    {
        fprintf(stderr,"Create Share Memory Error： %s\n\a",strerror(errno));
        exit(1);
    }
    if(fork())
    {
        p_addr=shmat(shmid,0,0);
        memset(p_addr,'\0',1024);
        strncpy(p_addr,argv[1],1024);
        exit(0);
    }
    else
    {
        c_addr=shmat(shmid,0,0);
        printf("Client get %s",c_addr);
        exit(0);
    }
}
/*父进程将参数写入到共享内存,然后子进程把内容读出来.最后我们要使用 ip
crm 释放资源的.先用 ipcs 找出 ID 然后用 ipcrm shm ID 删除.*/

Linux系统编程5.消息管理

1. POSIX无名信号量

2. System V信号量

3. SystemV 消息队列

4. 共享内存

Linux系統編程3.時間概念

Linux系統編程4.信號處理

Linux系統編程6.線程操作

Linux系統編程5.消息管理

仿printf實現

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結