进程间通信：IPC-信号量

时间：2022-10-05 15:14:39
信号量：来源于美国铁路调度。
原语：原子操作。操作是完整的。没有人打断。
现在都是用system V 信号量。
semaphore:信号量、信号灯

微指令：指令集。
手机是arm处理器。

i++;     //做加法的时候，需要保护

信号量同共享内存一样，不会随着进程的结束而消失。

key_t ftok(const char *pathname, int proj_id);      //产生key。proj_id通常传入一非0字符。
int semget(key_t key,int nsems,int flag);  //创建或获取相应的信号量。返回信号量集ID。nsems=1表示1个信号量。
int semop(int semid,struct sembuf *sops,size_t num_sops);   //函数semop用于改变信号量对象中各个信号量的状态。sops是一个                                                                                                   结构体数组指针。num_sops表示数组元素个数。结构体数组传进 来的                                                                                                   时候弱化为指针， 所 以 需要一个变量来说明数组元素的个数。即将要操                                                                                               作的信号量的个数。struct sembuf结 构体如下所示。semop()函数是一                                                                                                  个原子操作。                                                                                       
int semctl(int semid, int semnum, int cmd, …);   // cmd通常为：IPC_RMID、GETVAL、SETVAL、GETALL、SETALL。semnum为                                                                             信号量集中的信号量的编号，第一个信号量为0.
                                                                            IPC_RMID:立即删除信号集，唤醒所有被阻塞的进程
                                SETVAL :根据semun设定信号的值，从0开始，第一个信号量编号为0   
                                                                           GETVAL :根据semun返回信号量的值，从0开始，第一个信号量编号为0                                                                                              GETALL :获取所有信号量的值,第二个参数为0，将所有信号的值存入semun.array中                                                                            SETALL    :将所有semun.array的值设定到信号集中，第二个参数为0.
struct sembuf{                         
  short sem_num;   //操作信号量在信号量集合中的编号，第一个信号量的编号是0。                         
  short sem_op;     //sem_op成员的值是信号量在一次操作中需要改变的数值。 通常只会用到两个值，一个是-1，也就是p操作，                                     它等 待信号量变为可用；一个是+1，也就是v操作，它发送信号通知信号量现在可用。
  short sem_flg;     //通常设为： SEM_UNDO，程序结束，信号量为semop调用前的值。防止对信号量-1了之后，没有+1就退出                                      了，他人都在等你。
}; 

例子1：     
int main(){
        int semid= semget((key_t)1234, 1,IPC_CREAT|0600);    //信号量跟共享内存一样，不会随着进程的结束而消失。1表示创建一                                                                                                 个信号量。创建完成后,用ipcs命令可以看到：信号量集的ID以及该信号                                                                                                量集有几个信号量。
        if(-1==semid){
                perror("semget");
                return -1;
        }
        int ret= semctl(semid,0, SETVAL,1);                    //SETVAL表示要设定信号量的值。semid是信号量集ID。0表示信号量集中的                                                                                       第一个信号量。将第一个信号量的值设为1.信号量只能设置成正值。
        if(-1==ret){
                perror("semctl");
                return -1;
        }
        ret= semctl(semid,0, GETVAL);                                    //GETVAL表示获取信号量的值。semid是信号量集ID。0为第一个信号。
        printf("ret=%d\n",ret);
        return 0;
}

例2：创建多个信号量：

//创建一个信号量集合，集合中含有多个信号量
int main(){
        int semid=semget((key_t)1234, 2,IPC_CREAT|0600);       //创建信号量集，返回信号量集ID。里面含有2个信号量。
        if(-1==semid){
                perror("semget");
                return -1;
        }
        unsigned short array[2]={1,2};
        int ret=semctl(semid,0, SETALL,array);                     //cmd填SETALL,可以设置所有的信号量。填了SETALL,第二个参数没用。
        if(-1==ret){
                perror("semctl");
                return -1;
        }
        memset(array,0,sizeof(array));       
        ret=semctl(semid,0, GETALL,array);                                //会重新放到array
        if(-1==ret){
                perror("semctl1");
                return -1;
        }
        printf("array[0]=%d,array[1]=%d\n",array[0],array[1]);     //打印出1，2
        ret=semctl(semid,0, IPC_RMID);                                   信号量集合删除：IPC_RMID    
        if(-1==ret){
                perror("semctl");
                return -1;
        }
        return 0;
}       

例子3：       
第一步：vim zero.c             //创建共享内存，给共享内存的第一个int型数据赋初值0
int main(){
        int shmid=shmget((key_t)1234,20,IPC_CREAT|0600);
        if(-1==shmid){
                perror("shmget");
                return -1;
        }
        int* i;
        i=(int*)shmat(shmid,NULL,0);
        *i=0;                                                     //修改i的值为0.
        printf("%d\n",*i);
        return 0;
}

第二步：vim add1.c
    vim add2.c
add1.c      
int main(){
        int shmid=shmget((key_t)1234,20,IPC_CREAT|0600);
        if(-1==shmid){
                perror("shmget");
                return -1
        }
        int* i;
        i=(int*)shmat(shmid,NULL,0);    //连接共享内存
        int j;
        int  semid= semget((key_t)1234,1,IPC_CREAT|0600);
        int ret= semctl(semid,0,SETVAL,1);  //给信号量赋初值1
        if(-1==ret){
                perror("semctl");
                return -1;
        }
         struct sembuf sp;         //定义p操作的结构体sp。
        memset(&sp,0,sizeof(sp));
         sp.sem_num=0;          //第一个信号量编号为0.
         sp.sem_op=-1;           //信号量在一次操作中需要-1.
        sp.sem_flg=SEM_UNDO;

         struct sembuf sv;      //定义v操作的结构体sv
        memset(&sv,0,sizeof(sv));
         sv.sem_num=0;         //第一个信号量
         sv.sem_op=1;            //在一次操作中需要+1.
        sv.sem_flg=SEM_UNDO;

        for(j=0;j<20000000;j++){
                 semop(semid,&sp,1);  //传入sp[],数组元素个数1.
                  (*i)++;
                 semop(semid,&sv,1);
        }
        return 0;
}

add2.c      
int main(){
        int shmid=shmget((key_t)1234,20,IPC_CREAT|0600);
        if(-1==shmid){
                perror("shmget");
                return -1;
        }
        int* i;
        i=(int*)shmat(shmid,NULL,0);
        int j;
        int semid=semget((key_t)1234,1,IPC_CREAT|0600);
        int ret=semctl(semid,0,SETVAL,1);  
        if(-1==ret){
                perror("semctl");
                return -1;
        }
        struct sembuf sp;
        memset(&sp,0,sizeof(sp));
        sp.sem_num=0;
        sp.sem_op=-1;
        sp.sem_flg=SEM_UNDO;

        struct sembuf sv;
        memset(&sv,0,sizeof(sv));
        sv.sem_num=0;
        sv.sem_op=1;
        sv.sem_flg=SEM_UNDO;

        for(j=0;j<20000000;j++){
                semop(semid,&sp,1);
                (*i)++;
                semop(semid,&sv,1);
        }
        return 0;
}
注：信号量有信号量队列，共享内存有共享内存队列。所以用同一个key没有关系。
如果没有用信号量，在加法器中第一个进程从寄存器中取到n,然后加1操作，本来应该返回n+1之后，再从寄存器取出n+1，再加1。但是由于进程的并发，有可能还没有返回n+1。另一个进程就从寄存器中取数去加1了。
第三步：vim Makefile:                   //方便编译
add1:add1.c add2.c
        gcc add1.c -o add1
        gcc add2.c -o add2
.PHONY:clean
clean:
        rm add1 add2
第四步：vim printf.c                     //输出最后的值
int main(){
        int shmid=shmget((key_t)1234,20,IPC_CREAT|0600);
        if(-1==shmid){
                perror("shmget");
                return -1;
        }
        int* i;
        i=(int*)shmat(shmid,NULL,0);
        printf("%d\n",*i);
        return 0;
}
第五步:vim start.sh
./add1 &                          //把add1放到后台执行。这样就可以马上执行add2。
./add2
第六步：执行
./zero
make 
./start.sh
./printf


有后台执行程序时，ctrl +c 之后先ps-elf看看

命令：
ipcs  查看信号量
ipcrm -s semid   删除信号量集合






会立即执行。并把阻塞在当前信号量的进程唤醒。

ret=semctl(semid,0,IPC_RMID);
if(-1==ret){
  perror;
}


例4：获取信号量集合的属性，并进行一些设置。
struct semid_ds {               
 struct ipc_perm sem_perm;      //Ownership and permissions             
 time_t          sem_otime;          //Last semop time             
 time_t          sem_ctime;          //Last change time             
 unsigned long   sem_nsems;    // No. of semaphores in set         
 };       
       
struct ipc_perm {               
 key_t          __key;             //Key supplied to semget(2)                
 uid_t          uid;                  //Effective UID of owner             
 gid_t          gid;                  //Effective GID of owner            
 uid_t          cuid;                //Effective UID of creator        
 gid_t          cgid;                //Effective GID of creator             
 unsigned short mode;          //Permissions             
 unsigned short __seq;         //Sequence number      
 }; 

int main(){
        int semid=semget((key_t)1234,2,IPC_CREAT|0600);
        if(-1==semid){
                perror("semget");
                return -1;
        }
        struct semid_ds buf;
        memset(&buf,0,sizeof(buf));
        int ret=semctl(semid,0, IPC_STAT,&buf);
        if(-1==ret){
                perror("semctl");
                return -1;
        }
        printf("uid=%d,cuid=%d,mode=%o,nsems=%ld\n",buf.sem_perm.uid,buf.sem_perm.cuid,buf.sem_perm.mode,buf.sem_nsems);
        return 0;
}

例5：生产者、消费者问题   

生产者进程：
int set_val(int semid){
         unsigned short array[2]={0,10};                                     //第一个信号量是：full，第二个信号量是empty
        int ret=semctl(semid,0, SETALL, array);                           //给信号量设初值：0，10 。这一步不能少，即使只有一个信号量。
        if(-1==ret){
                perror("semctl");
                return -1; 
        }
        memset(array,0,sizeof(array));       
        ret=semctl(semid,0,GETALL,array);
        if(-1==ret){
                perror("semctl1");
                return -1;
        }
        printf("array[0]=%d,array[1]=%d\n",array[0],array[1]);      //打印出来看看
}

int main(){
        int semid=semget((key_t)1234, 2,IPC_CREAT|0600);       //打开或创建信号量集，返回信号量集ID，信号量集中有2个信号。
        if(-1==semid){
                perror("semget");
                return -1;
        }
        set_val(semid);                                                     //调用函数，给信号量设初值
         struct sembuf sp[2];     //每个结构体代表一个信号，这个结构体中有这个信号的编号及信号的操作，这都是需要单独设置 的。                                                 semop函数只做一件事：从哪个信号开始执行操作，操作几个。会把这几个结构体的操作都执行一遍。
         sp[0].sem_num=0;              //sp[0]=full。sp[1]=empty。
         sp[0].sem_op=1;                //v(full)
         sp[0].sem_flg=SEM_UNDO;
         sp[1].sem_num=1;             
         sp[1].sem_op=-1;    //p(empty)
         sp[1].sem_flg=SEM_UNDO;
        while(1){
                printf("product num=%d,space num=%d\n",semctl(semid,0,GETVAL),semctl(semid,1,GETVAL));
                 semop(semid,&sp[1],1);   //semid是信号量集的ID。1表示将要对1个信号量进行操作。这句话的意思是：对semid这个信                                                             号集 中的从sp[1]开始的1个信号量进行操作。生产者：p(empty).
                printf("I will produce\n");
                 semop(semid,&sp[0],1);    //v(full)
                printf("product num=%d,space num=%d\n",semctl(semid,0,GETVAL),semctl(semid,1,GETVAL));
                sleep(2);
        }       
        return 0;
}       

消费者进程：
int main(){
        int semid=semget((key_t)1234,2,IPC_CREAT|0600);
        if(-1==semid){
                perror("semget");
                return -1;
        }
        struct sembuf sp[2];
        sp[0].sem_num=0;
        sp[0].sem_op=-1;                         //p(full)
        sp[0].sem_flg=SEM_UNDO;
        sp[1].sem_num=1;
        sp[1].sem_op=1;                          //v(empty)
        sp[1].sem_flg=SEM_UNDO;
        while(1){
                printf("product num=%d,space num=%d\n",semctl(semid,0,GETVAL),semctl(semid,1,GETVAL));
                semop(semid,&sp[0],1);       //p(full)
                printf("I will eat\n");
                semop(semid,&sp[1],1);    //v(empty)
                printf("product num=%d,space num=%d\n",semctl(semid,0,GETVAL),semctl(semid,1,GETVAL));
                sleep(3);
        }       
        return 0;
}       


标签：

相关文章