• Linux学习——进程间通信

    目录

    一、概念：

    二、常用通信方式

    三、无名管道

    无名管道注意事项：

    无名管道的读写特性：

    四、有名管道（命名管道）

    创建管道

    特点：

    注意事项：

    五、内存映射

    概念：

    mmap()的优点：

    函数定义：

    注意事项：

    mmap()映射的种类：

    六、System V共享内存

    两种共享内存的比较：

    System-V详细介绍：

    共享内存

    system V 共享内存使用步骤：

    七、信号机制

    概念：

    信号的产生：（软中断）

    信号处理方式：

    常用信号：

    信号命令：

    信号的函数：

    定时器函数

    定时器的实现

    信号集、信号屏蔽和阻塞

    信号的状态：

    信号集操作函数

     八、消息队列

    概念：

    消息队列的使用：

    消息格式：

    消息的接收：

    九、信号灯/信号量（semaphore）

    概念：

    三种信号灯：

    Posix 有名信号灯和无名信号灯使用：

    进程间通信（IPC，InterProcess Communication）

    一、概念：

    就是进程和进程之间交换信息。

    二、常用通信方式

    无名管道（pipe）

    有名管道 （fifo）

    信号（signal）  //重点

    共享内存(mmap)

    套接字（socket）    //目前主流方式，还可用于主机通信

    过时的IPC通信方式

    System V IPC

    共享内存（share memory）

    消息队列（message queue）

    信号灯集（semaphore set）

    三、无名管道

     

    int pipe(int pfd[2]); 成功：0；失败：-1，设置errno

    pfd[0] 为读描述符

    pfd[1] 为写描述符

    无名管道注意事项：

    1. 只能用于亲缘关系的进程间通信（父子进程，兄弟进程）
    1. 管道通信是单工的，一端读，一端写（程序实现设计好）。
    2. 数据自己读不能自己写
    3. 管道可以用于大于2个进程共享

    简单的程序：

    1. #include 
    2. #include 
    3. #include 
    4. int main(){
    5.     int pfd[2];
    6.     int re;
    7.     char buf[20]={0};
    8.     pid_t pid;
    9.     re = pipe(pfd);
    10.     if(re<0){
    11.         perror("pipe");
    12.         return 0;
    13.     }
    14.     //printf("%d,%d\n",pfd[0],pfd[1]);
    15.     pid = fork();
    16.     if(pid<0){
    17.         perror("fork");
    18.         return 0;
    19.     }else if(pid == 0){
    20.         //close(pfd[0]);
    21.         while(1){
    22.             strcpy(buf,"hhahahahah");
    23.             write(pfd[1],buf,strlen(buf));
    24.  
    25.             sleep(1);
    26.         }
    27.  
    28.     }else{
    29.        // close(pfd[1]);        
    30.        while(1){
    31.             re=read(pfd[0],buf,20);
    32.             if(re>0){
    33.                 printf("read pipe=%s\n",buf);
    34.             }    
    35.         }
    36.     }
    37.  
    38.  
    39. }

    结果：

    现在让父进程来写：

    1. #include 
    2. #include 
    3. #include 
    4. int main(){
    5.     int pfd[2];
    6.     int re;
    7.     char buf[20]={0};
    8.     pid_t pid;
    9.     re = pipe(pfd);
    10.     if(re<0){
    11.         perror("pipe");
    12.         return 0;
    13.     }
    14.     printf("%d,%d\n",pfd[0],pfd[1]);
    15.     pid = fork();
    16.     if(pid<0){
    17.         perror("fork");
    18.         return 0;
    19.     }else if(pid > 0){
    20.         close(pfd[0]);
    21.         while(1){
    22.             strcpy(buf,"hhahahahah");
    23.             write(pfd[1],buf,strlen(buf));
    24.  
    25.             sleep(1);
    26.         }
    27.  
    28.     }else{
    29.        close(pfd[1]);        
    30.        while(1){
    31.             re=read(pfd[0],buf,20);
    32.             if(re>0){
    33.                 printf("read pipe=%s\n",buf);
    34.             }    
    35.         }
    36.     }
    37.  
    38.  
    39. }

     

    结果：

     

    无名管道的读写特性：

    • 读管道：

    1. 管道中有数据，read返回实际读到的字节数。

    2. 管道中无数据：

    (1) 管道写端被全部关闭，read返回0 (相当于读到文件结尾)

      (2) 写端没有全部被关闭，read阻塞等待(不久的将来可能有数据递达，此时会让出cpu）

    • 写管道：

    1. 管道读端全部被关闭， 进程异常终止(也可使用捕捉SIGPIPE信号，使进程不终止）

    2. 管道读端没有全部关闭：

      (1) 管道已满，write阻塞。（管道大小64K）

    （2）管道未满，write将数据写入，并返回实际写入的字节数。

    1. #include 
    2. #include 
    3. #include 
    4. int main(){
    5.     int pfd[2];
    6.     int i;
    7.     int re;
    8.     char buf[40]={0};
    9.     pid_t pid;
    10.     re = pipe(pfd);
    11.     if(re<0){
    12.         perror("pipe");
    13.         return 0;
    14.     }
    15.     printf("%d,%d\n",pfd[0],pfd[1]);
    16.  
    17.     for(i=0;i<2;i++){
    18.         pid = fork();
    19.         if(pid<0){
    20.             perror("fork");
    21.             return 0;
    22.         }else if(pid>0){
    23.  
    24.         }else{
    25.             break;   
    26.             
    27.         }
    28.     }
    29.     if(i==2){
    30.         close(pfd[1]);
    31.         while(1){
    32.             memset(buf,0,40);
    33.             re=read(pfd[0],buf,40);
    34.             if(re>0){
    35.                 printf("%s\n",buf);
    36.             }    
    37.         }
    38.         return 0;
    39.     }
    40.  
    41.     if(i==1){
    42.         close(pfd[0]);
    43.         while(1){
    44.             strcpy(buf,"this is 2 process");
    45.             write(pfd[1],buf,strlen(buf));
    46.             usleep(930000);
    47.         }
    48.         return 0;
    49.     }
    50.     if(i==0){
    51.         close(pfd[0]);
    52.         while(1){
    53.             strcpy(buf,"this is 1 process");
    54.             write(pfd[1],buf,strlen(buf));
    55.             sleep(1);
    56.         }
    57.  
    58.         return 0;
    59.     }
    60.  
    61.  
    62. }

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. int main(){
    6.     int pfd[2];
    7.     int re;
    8.     char buf[20]={0};
    9.     pid_t pid;
    10.     re = pipe(pfd);
    11.     if(re<0){
    12.         perror("pipe");
    13.         return 0;
    14.     }
    15.     printf("%d,%d\n",pfd[0],pfd[1]);
    16.     pid = fork();
    17.     if(pid<0){
    18.         perror("fork");
    19.         return 0;
    20.     }else if(pid>0){
    21.         close(pfd[0]);
    22. //        close(pfd[1]);
    23.         int j=0;
    24.         while(1){
    25.             j++;
    26.             strcpy(buf,"hhahahahah");
    27.             for(int i=0;i<1000;i++){
    28.                 write(pfd[1],buf,strlen(buf));
    29.             }
    30.             printf("write %d times\n",j);
    31.             sleep(1);
    32.         }
    33.  
    34.     }else{
    35.         close(pfd[1]); 
    36.        // close(pfd[0]);
    37.         sleep(30000);
    38.         exit(0);
    39.        while(1){
    40.             re=read(pfd[0],buf,20);
    41.             if(re>0){
    42.                 printf("read pipe=%s\n",buf);
    43.             }else if(re==0){
    44.                 printf("re=0\n");
    45.             }
    46.         }
    47.     }
    48.  
    49.  
    50. }

     

     

    四、有名管道（命名管道）

    就像一个队列

    创建管道

    #include

    #include

    int mkfifo(const char *filename, mode_t mode);

    open(const char *path, O_RDONLY);//1

    open(const char *path, O_RDONLY | O_NONBLOCK);//2

    open(const char *path, O_WRONLY);//3

    open(const char *path, O_WRONLY | O_NONBLOCK);//4

    特点：

    1有名管道可以使非亲缘的两个进程互相通信

    2通过路径名来操作，在文件系统中可见，但内容存放在内存中

    3 文件IO来操作有名管道

    4 遵循先进先出规则

    5 不支持leek操作

    6 单工读写

    注意事项：

    1 就是程序不能以O_RDWR(读写)模式打开FIFO文件进行读写操作，而其行为也未明确定义，因为如一个管道以读/写方式打开，进程可以读回自己的输出，同时我们通常使用FIFO只是为了单向的数据传递

    2 第二个参数中的选项O_NONBLOCK，选项O_NONBLOCK表示非阻塞，加上这个选项后，表示open调用是非阻塞的，如果没有这个选项，则表示open调用是阻塞的

    3  对于以只读方式（O_RDONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_RDONLY），除非有一个进程以写方式打开同一个FIFO，否则它不会返回；如果open调用是非阻塞的的（即第二个参数为O_RDONLY | O_NONBLOCK），则即使没有其他进程以写方式打开同一个FIFO文件，open调用将成功并立即返回。

    对于以只写方式（O_WRONLY）打开的FIFO文件，如果open调用是阻塞的（即第二个参数为O_WRONLY），open调用将被阻塞，直到有一个进程以只读方式打开同一个FIFO文件为止；如果open调用是非阻塞的（即第二个参数为O_WRONLY | O_NONBLOCK），open总会立即返回，但如果没有其他进程以只读方式打开同一个FIFO文件，open调用将返回-1，并且FIFO也不会被打开。

    4.数据完整性,如果有多个进程写同一个管道，使用O_WRONLY方式打开管道，如果写入的数据长度小于等于PIPE_BUF（4K），那么或者写入全部字节，或者一个字节都不写入，系统就可以确保数据决不会交错在一起。

    使用非阻塞方式打开：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9.  
    10. int main(){
    11.     int re;
    12.     int fd;
    13.     char buf[32];
    14.     //re = mkfifo("/home/book/Desktop/Lv5/Day6/myfifo",0666);
    15. 	re = mkfifo("./myfifo",0666);
    16.     if(re<0){
    17.         perror("mkfifo");
    18.         //return 0;
    19.     }
    20.     fd = open("./myfifo",O_WRONLY|O_NONBLOCK);
    21.     if(fd<0){
    22.         perror("open");
    23.         return 0;
    24.     }
    25.     printf("after open\n");
    26.     while(1){
    27.         fgets(buf,32,stdin);
    28.         write(fd,buf,strlen(buf));
    29.  
    30.     }
    31. }
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9.  
    10. int main(){
    11.     int re;
    12.     int fd;
    13.     char buf[32];
    14. /*
    15.     re = mkfifo("/myfifo",0666);
    16.     if(re<0){
    17.         perror("mkfifo");
    18.         return 0;
    19.     }
    20.     */
    21.     fd = open("./myfifo",O_RDONLY);
    22.     if(fd<0){
    23.         perror("open");
    24.         return 0;
    25.     }
    26.     printf("after open\n");
    27.     while(1){
    28.         
    29.         re=read(fd,buf,32);
    30.         if(re>0){
    31.             printf("read fifo=%s\n",buf);
    32.         }else if(re==0){
    33.             exit(0);
    34.         }
    35.  
    36.     }
    37. }

     

     非阻塞状态打开一定要先打开读在打开写不然会打不开（所以最好加上阻塞）

     

     现在通过有名管道进行通信。

     

    五、内存映射

    概念：

    使一个磁盘文件与内存中的一个缓冲区相映射，进程可以像访问普通内存一样对文件进行访问，不必再调用read,write。

    mmap()的优点：

    实现了用户空间和内核空间的高效交互方式

     

     

     

    函数定义：

    void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);              

    功能：创建共享内存映射

    函数返回值：成功返回创建的映射区首地址，失败返回MAP_FAILED（ ((void *) -1) ），设置errno值

    参数说明：

    addr：指定要映射的内存地址，一般设置为 NULL 让操作系统自动选择合适的内存地址。

    length：必须>0。映射地址空间的字节数，它从被映射文件开头 offset 个字节开始算起。

    prot：指定共享内存的访问权限。可取如下几个值的可选：PROT_READ（可读）, PROT_WRITE（可写）, PROT_EXEC（可执行）, PROT_NONE（不可访问）。

    flags：由以下几个常值指定：MAP_SHARED（共享的） MAP_PRIVATE（私有的）, MAP_FIXED（表示必须使用 start 参数作为开始地址，如果失败不进行修正），其中，MAP_SHARED , MAP_PRIVATE必选其一，而 MAP_FIXED 则不推荐使用。MAP_ANONYMOUS（匿名映射，用于血缘关系进程间通信）

    fd：表示要映射的文件句柄。如果匿名映射写-1。（就是文件描述符）

    offset：表示映射文件的偏移量，一般设置为 0 表示从文件头部开始映射。

    注意事项：

    （1） 创建映射区的过程中，隐含着一次对映射文件的读操作，将文件内容读取到映射区。

    （2） 当MAP_SHARED时，要求：映射区的权限应 <=文件打开的权限(出于对映射区的保护)，如果不满足报非法参数（Invalid argument）错误。

    当MAP_PRIVATE时候，mmap中的权限是对内存的限制，只需要文件有读权限即可，操作只在内存有效，不会写到物理磁盘，且不能在进程间共享。

    （3） 映射区的释放与文件关闭无关，只要映射建立成功，文件可以立即关闭。（没映射成功前不能关闭）

    （4） 用于映射的文件大小必须>0，当映射文件大小为0时，指定非0大小创建映射区，访问映射地址会报总线错误，指定0大小创建映射区，报非法参数错误（Invalid argument）

    （5） 文件偏移量必须为0或者4K的整数倍（不是会报非法参数Invalid argument错误）.

    （操作系统的内存是一页一页分配的一页就是4k）

        操作系统——内存分配与管理_王王仙贝~的博客-CSDN博客_操作系统内存分配

    （6）映射大小可以大于文件大小，但只能访问文件page的内存地址，否则报总线错误（下图中剩余部分） ，超出映射的内存大小报段错误

     

     

    （7）mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。

    mmap()映射的种类：

    1基于文件的映射

    2 匿名映射

    适用于具有亲缘关系的进程之间，

    释放内存映射

    munmap函数

    int munmap(void *addr, size_t length);

    返回值：成功返回0，失败返回-1，并设置errno值。

    函数参数：

    addr：调用mmap函数成功返回的映射区首地址

    length：映射区大小（即：mmap函数的第二个参数）

    实验一：
     

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. #include 
    8. #include 
    9. #include 
    10.  
    11.  
    12. int main(){
    13.     
    14.     void *addr;
    15.     int fd;
    16.     fd =open("test",O_RDWR);
    17.     if(fd<0){
    18.         perror("open");
    19.         return 0;
    20.     }
    21.    // int len = lseek(fd,0,SEEK_END);    
    22.     addr = mmap(NULL,2048, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    23.     if(addr == MAP_FAILED){
    24.         perror("mmap");
    25.         return 0;
    26.     }
    27.    // close(fd);
    28.     //int i=0;
    29.     //while(i<2048){
    30.        // memcpy((addr+i),"a",1);
    31.        // i++;
    32.        // sleep(1);
    33.    // }    
    34. 	memcpy(addr,"abcdefg",7);
    35. //    printf("read=%s\n",(char*)(addr));
    36.  
    37.  
    38.  
    39. }

    文件需要提前创建，文件要有内存，不然会总线错误 

     

     创建的时候加几个空格

    但是不全因为文件大小在那里加几个回车就全了

     

    接下来把文件改一下加上读语句

    printf("read=%s\n",(char*)(addr));

     

     

     实验二：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. #include 
    8. #include 
    9. #include 
    10.  
    11.  
    12. int main(){
    13.     
    14.     void *addr;
    15.     int fd;
    16.     fd =open("test",O_RDWR);
    17.     if(fd<0){
    18.         perror("open");
    19.         return 0;
    20.     }
    21.    // int len = lseek(fd,0,SEEK_END);    
    22.     addr = mmap(NULL,2048, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    23.     if(addr == MAP_FAILED){
    24.         perror("mmap");
    25.         return 0;
    26.     }
    27.     close(fd);
    28. 	memcpy(addr,"aaaaaaaaaaaaaaa",15);
    29.     //int i=0;
    30.     //while(i<2048){
    31.        // memcpy((addr+i),"a",1);
    32.        // i++;
    33.        // sleep(1);
    34.    // }    
    35. 	//memcpy(addr,"abcdefg",7);
    36. 	printf("read=%s\n",(char*)(addr));
    37.  
    38.  
    39.  
    40. }

     

     读程序：

    1. #if 1
    2.  
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. #include 
    11. #include 
    12. #include 
    13.  
    14.  
    15. int main(){
    16.     
    17.     void *addr;
    18.     int fd;
    19.     fd =open("test",O_RDWR);
    20.     if(fd<0){
    21.         perror("open");
    22.         return 0;
    23.     }
    24.     int len = lseek(fd,0,SEEK_END);    
    25.     addr = mmap(NULL,2048, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    26.     if(addr == MAP_FAILED){
    27.         perror("mmap");
    28.         return 0;
    29.     }
    30.     close(fd);
    31. //    memcpy((addr),"99999999999999",15);
    32.     while(1){
    33.         printf("read=%s\n",(char*)(addr));
    34.         sleep(1);
    35.     }
    36.  
    37.  
    38. }
    39. #endif

     写程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. #include 
    8. #include 
    9. #include 
    10.  
    11.  
    12. int main(){
    13.     
    14.     void *addr;
    15.     int fd;
    16.     fd =open("test",O_RDWR);
    17.     if(fd<0){
    18.         perror("open");
    19.         return 0;
    20.     }
    21.     int len = lseek(fd,0,SEEK_END);    
    22.     addr = mmap(NULL,2048, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    23.     if(addr == MAP_FAILED){
    24.         perror("mmap");
    25.         return 0;
    26.     }
    27.     close(fd);
    28. 	memcpy(addr,"aaaaaaaaaaaaaaa",15);
    29.     int i=0;
    30.     while(i<2048){
    31.        memcpy((addr+i),"a",1);
    32.        i++;
    33.        sleep(1);
    34.    }    
    35. 	//memcpy(addr,"abcdefg",7);
    36. 	
    37.  
    38. 	//printf("read=%s\n",(char*)(addr));
    39.  
    40.  
    41.  
    42. }

     结果是这样的

    试了好几次都是前面没变化后面开始加，把插入的字符换个1试试：

     先开启写后开启读，为什么会是从前面开始加的呢。

    改成16试试：

    这次我是先开始读的读到几个111111后面全是a了，这是什么情况。 

     在改成纯i试试，之接报错了，addr是一个指针i只是他的偏移量。改成3试试

    在第三个位置开始加了，但是不够直观改进代码让他每次插入的数据都不一样：

    我开始想的是数组加strcpy后来这个转换老报错运行还段错误，所以还是用sprintf把他变成字符串把 

     终于是我想要的了，还有个问题test第一行的空格数量决定他能跑到多少，超过文件大小就写不进去了。具体原因以后再来看现在直接深挖要学很多东西。

     

    代码如下：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. #include 
    8. #include 
    9. #include 
    10.  
    11.  
    12. int main(){
    13.     
    14.     void *addr;
    15.     int fd;
    16.     fd =open("test",O_RDWR);
    17.     if(fd<0){
    18.         perror("open");
    19.         return 0;
    20.     }
    21.     int len = lseek(fd,0,SEEK_END);    
    22.     addr = mmap(NULL,2048, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    23.     if(addr == MAP_FAILED){
    24.         perror("mmap");
    25.         return 0;
    26.     }
    27.     close(fd);
    28. 	memcpy(addr,"aaaaaaaaaaaaaaa",15);
    29.     int i=0,b=1,c=0;
    30. 	char a[4];
    31. 	//sprintf(a,)
    32. 	//a[0] = 0;
    33.     while(i<2048){
    34. 		sprintf(a,"%d",i);
    35. 		if(i>9){b = 2;}
    36. 		if(i>10){c++;}
    37.         memcpy((addr+i+c),a,b);
    38.         i++; 
    39. 		sleep(1);
    40.    }    
    41. 	//memcpy(addr,"abcdefg",7);
    42. 	
    43.  
    44. 	//printf("read=%s\n",(char*)(addr));
    45.  
    46.  
    47.  
    48. }

    父子进间进行匿名通信：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. int main(){
    13.  
    14.     void *addr;
    15.     
    16.     addr = mmap(NULL,2048, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
    17.     if(addr == MAP_FAILED){
    18.         perror("mmap");
    19.         return 0;
    20.     }
    21.     pid_t pid;
    22.     pid = fork();
    23.  
    24.     if(pid<0){
    25.         perror("fork");
    26.         return 0;
    27.     }
    28.     else if(pid>0){
    29.         memcpy(addr,"1234567890",10);
    30.          
    31.         wait(NULL);
    32.     }else {
    33.         sleep(1);
    34.         printf("read father val=%s\n",(char *)addr);
    35.  
    36.         
    37.  
    38.     }
    39.     
    40.     munmap(addr,2048);
    41.  
    42. }

     结果：

     

    六、System V共享内存

    两种共享内存的比较：

    linux 内存文件共享,两种Linux共享内存的比较_weixin_39544333的博客-CSDN博客

    System-V详细介绍：

    Linux-C 进程通信之system-V IPC_Genven_Liang的博客-CSDN博客

    共享内存

    IPC 的key

     

    ftok函数

     key_t  ftok(const char *path,  int id);

      其中参数path是指定的文件名，这个文件必须是存在的而且可以访问的。id是子序号，它是一个8bit的整数。即范围是0~255。当函数执行成功，则会返回key_t键值，否则返回-1。在一般的UNIX中，通常是将文件的索引节点取出，然后在前面加上子序号就得到key_t的值

    程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. int main(){
    8.     key_t key;
    9.     int shmid;
    10.     char *buf;
    11.     key = ftok("keytest",100);
    12.     if(key<0){
    13.         perror("ftok");
    14.         return 0;
    15.     }
    16.     printf("key=%x\n",key);
    17.  
    18.     shmid = shmget(key,512,IPC_CREAT|0666);
    19.  
    20.     if(shmid<0){
    21.         perror("shmget");
    22.         return 0;
    23.     }
    24.     
    25.     printf("shmid=%d\n",shmid);
    26.     
    27.     buf = shmat(shmid,NULL,0);
    28.     if(buf<0){
    29.         perror("shmat");
    30.         return 0;
    31.     }    
    32.     strcpy(buf,"hello world");
    33.     
    34. }

    结果：

     

     

     

    system V 共享内存使用步骤：

    1创建/打开共享内存

    2映射共享内存，即把指定的共享内存映射到进程的地址空间用于访问

    3 读写共享内存

    4 撤销共享内存映射

    5 删除共享内存对象

    查看共享内存命令ipcs

    共享内存创建 – shmget

    int shmget(key_t key, int size, int shmflg);

    共享内存映射

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

    第二个参数一般写NULL，表示自动映射

    第三参数一般写0 ，表示可读写

    共享内存撤销

     int  shmdt(void *shmaddr);

    撤销后，内存地址不可再访问。（只是不能用了他还在）

    共享内存控制

    int  shmctl(int shmid, int cmd, struct shmid_ds *buf);

    shmctl(shmid, IPC_RMID, NULL);删除共享内存

    写程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. int main(){
    8.     key_t key;
    9.     int shmid;
    10.     char *buf;
    11.     key = ftok("keytest",100);
    12.     if(key<0){
    13.         perror("ftok");
    14.         return 0;
    15.     }
    16.     printf("key=%x\n",key);
    17.  
    18.     shmid = shmget(key,512,IPC_CREAT|0666);
    19.  
    20.     if(shmid<0){
    21.         perror("shmget");
    22.         return 0;
    23.     }
    24.     
    25.     printf("shmid=%d\n",shmid);
    26.     
    27.     buf = shmat(shmid,NULL,0);
    28.     if(buf<0){
    29.         perror("shmat");
    30.         return 0;
    31.     }    
    32.     strcpy(buf,"hello world");
    33.     
    34. }

    读程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. int main(){
    9.     key_t key;
    10.     int shmid;
    11.     char *buf;
    12.     key = ftok("keytest",100);
    13.     if(key<0){
    14.         perror("ftok");
    15.         return 0;
    16.     }
    17.     printf("key=%x\n",key);
    18.  
    19.     shmid = shmget(key,512,0666);
    20.  
    21.     if(shmid<0){
    22.         perror("shmget");
    23.         return 0;
    24.     }    
    25.     printf("shmid=%d\n",shmid);
    26.    
    27.     buf = shmat(shmid,NULL,0);
    28.     if(buf<0){
    29.         perror("shmat");
    30.         return 0;
    31.     }    
    32. //    strcpy(buf,"hello world");
    33.     printf("share mem=%s\n",buf);
    34.     while(1){
    35.         sleep(1);
    36.     }    
    37.     shmdt(buf);
    38.     shmctl(shmid, IPC_RMID, NULL);
    39.  
    40. //    printf("detach mem=%s\n",buf);
    41.  
    42. }

    运行结果：

     

     没人用了，把while注释掉让他可以执行删除语句，现在查看就没有共享内存了。

     

     

    七、信号机制

    概念：

    信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式

    所有信号的产生及处理全部都是由内核完成的

    信号的产生：（软中断）

    1 按键产生

    2 系统调用函数产生（比如raise， kill）

    3 硬件异常

    4 命令行产生 （kill）

    5 软件条件（比如被0除，访问非法内存等）

    信号处理方式：

    1 缺省方式

    2 忽略信号

    3 捕捉信号

    常用信号：

    信号名

    含义

    默认操作

    SIGHUP

    该信号在用户终端关闭时产生，通常是发给和该

    终端关联的会话内的所有进程

    终止

    SIGINT

    该信号在用户键入INTR字符(Ctrl-C)时产生，内

    核发送此信号送到当前终端的所有前台进程

    终止

    SIGQUIT

    该信号和SIGINT类似，但由QUIT字符(通常是

    Ctrl-\)来产生

    终止

    SIGILL

    该信号在一个进程企图执行一条非法指令时产生

    终止

    SIGSEV

    该信号在非法访问内存时产生，如野指针、缓

    冲区溢出

    终止

    SIGPIPE

    当进程往一个没有读端的管道中写入时产生，代

    表“管道断裂”

    终止

    信号名

    含义

    默认操作

    SIGKILL

    该信号用来结束进程，并且不能被捕捉和忽略

    终止

    SIGSTOP

    该信号用于暂停进程，并且不能被捕捉和忽略

    暂停进程

    SIGTSTP

    该信号用于暂停进程，用户可键入SUSP字符(

    通常是Ctrl-Z)发出这个信号

    暂停进程

    SIGCONT

    该信号让进程进入运行态

    继续运行

    SIGALRM

    该信号用于通知进程定时器时间已到

    终止

    SIGUSR1/2

    该信号保留给用户程序使用

    终止

    SIGCHLD

    是子进程状态改变发给父进程的。

    忽略

    信号命令：

    kill [-signal] pid

    killall [-u  user | prog]

    prog指定进程名

    17）子进程改变时发给父进程的信号

    9）一定能杀死

    15）直接kill的默认值不一定能杀死 

    信号的函数：

    int kill（pid_t pid, int signum）

    功能：发送信号

    参数：

                     pid:         > 0:发送信号给指定进程

                             = 0：发送信号给跟调用kill函数的那个进程处于同一进程组的进程。

                             < -1: 取绝对值，发送信号给该绝对值所对应的进程组的所有组员。

                             = -1：发送信号给，有权限发送的所有进程。

                     signum：待发送的信号

    int  raise(int sig);      

    给自己发信号，等价于kill(getpid(), signo);

    定时器函数

    unsigned int alarm(unsigned int seconds);

    功能：定时发送SIGALRM给当前进程

    参数：             seconds：定时秒数

    返回值：上次定时剩余时间。

    ualarm （循环发送）

    1. #include 
    2. #include 
    3. #include 
    4. int main(){
    5.     
    6. //    kill(24149,11);
    7. //   raise(11);
    8.    alarm(3);
    9.    pause();
    10. //   while(1){
    11. //   }
    12. }

     

     

    useconds_t ualarm(useconds_t usecs, useconds_t interval);

    以useconds为单位，第一个参数为第一次产生时间，第二个参数为间隔产生

    int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value);

    功能：定时的发送alarm信号

    参数：

    which： 

    ITIMER_REAL：以逝去时间递减。发送SIGALRM信号（常用）

    ITIMER_VIRTUAL: 计算进程（用户模式）执行的时间。 发送SIGVTALRM信号

    ITIMER_PROF: 进程在用户模式（即程序执行时）和核心模式（即进程调度用时）均计算时间。 发送SIGPROF信号

    new_value：  负责设定 timout 时间               

    old_value：   存放旧的timeout值，一般指定为NULL

    struct itimerval {

    struct timeval it_interval;  // 闹钟触发周期

    struct timeval it_value;    // 闹钟触发时间

    };

    struct timeval {

        time_t      tv_sec;         /* seconds */

        suseconds_t tv_usec;        /* microseconds */

    };

    信号的捕捉

     

    信号捕捉过程：

    1. 定义新的信号的执行函数handle。
    2. 使用signal/sigaction 函数，把自定义的handle和指定的信号相关联。

    signal函数：

    typedef void (*sighandler_t)(int);

    sighandler_t  signal(int signum, sighandler_t handler);//这是一个函数指针

    功能：捕捉信号执行自定义函数

    返回值：成功时返回原先的信号处理函数，失败时返回SIG_ERR

    参数：

     signo 要设置的信号类型

     handler 指定的信号处理函数: SIG_DFL代表缺省方式; SIG_IGN 代表忽略信号; 

    系统建议使用sigaction函数，因为signal在不同类unix系统的行为不完全一样。

    程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. typedef void (*sighandler_t)(int);
    9.  
    10. sighandler_t oldact;
    11.  
    12. void handle(int sig){
    13.     printf("I cath the SIGINT \n");
    14. //    signal(SIGINT,oldact);
    15. }
    16.  
    17. int main(){
    18.  
    19.     oldact = signal(SIGINT,handle);
    20.  
    21.     while(1){
    22.  
    23.         sleep(1);
    24.     }    
    25.  
    26.  
    27. }

    结果：

     如果取消注释，第一次ctrl+c后再次ctrl+c就会退出。

    sigaction函数：

    int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);

    struct sigaction {

        void (*sa_handler)(int);

        void (*sa_sigaction)(int, siginfo_t *, void *);

        sigset_t sa_mask;

        int sa_flags;

        void (*sa_restorer)(void);

    }

    参数：

    signum：处理的信号

    act,oldact: 处理信号的新行为和旧的行为，是一个sigaction结构体。

    sigaction结构体成员定义如下：

    sa_handler： 是一个函数指针，其含义与 signal 函数中的信号处理函数类似

    sa_sigaction： 另一个信号处理函数，它有三个参数，可以获得关于信号的更详细的信息。

    sa_flags参考值如下：

    SA_SIGINFO：使用 sa_sigaction 成员而不是 sa_handler 作为信号处理函数

    SA_RESTART：使被信号打断的系统调用自动重新发起。

    SA_RESETHAND：信号处理之后重新设置为默认的处理方式。

        SA_NODEFER：使对信号的屏蔽无效，即在信号处理函数执行期间仍能发出这个信号。

    re_restorer：是一个已经废弃的数据域

    程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. typedef void (*sighandler_t)(int);
    9.  
    10. sighandler_t oldact;
    11.  
    12. void handle(int sig){
    13.    if(sig == SIGINT){
    14.         printf("I cath the SIGINT \n");
    15.    }else if (sig==SIGALRM){
    16.        printf("second timer \n");
    17.        alarm(1);
    18.    }
    19.     //    signal(SIGINT,oldact);
    20. }
    21.  
    22. void mytimer(int sig){
    23.  
    24.  
    25. }
    26.  
    27.  
    28. int main(){
    29.     struct sigaction act;
    30.     act.sa_handler = handle;
    31.     act.sa_flags = 0;
    32.     sigemptyset(&act.sa_mask);
    33.     sigaction(SIGINT,&act,NULL);
    34.     alarm(1);
    35.     sigaction(SIGALRM,&act,NULL);
    36. //    oldact = signal(SIGINT,handle);
    37.  
    38.     while(1){
    39.         sleep(1);
    40.     }
    41.  
    42. }

    结果：

     

    定时器的实现

    程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9.  
    10. typedef void (*sighandler_t)(int);
    11.  
    12. sighandler_t oldact;
    13.  
    14. void handle(int sig){
    15.    if(sig == SIGINT){
    16.         printf("I cath the SIGINT \n");
    17.    }else if (sig==SIGALRM){
    18.        printf("second timer \n");
    19. //       alarm(1);
    20.    }
    21.     //    signal(SIGINT,oldact);
    22. }
    23.  
    24.  
    25. int main(){
    26.     struct sigaction act;
    27.     act.sa_handler = handle;
    28.     act.sa_flags = 0;
    29.     sigemptyset(&act.sa_mask);
    30. //    sigaction(SIGINT,&act,NULL);
    31. //    alarm(1);
    32.     struct itimerval timevalue;
    33.     timevalue.it_interval.tv_sec = 1;
    34.     timevalue.it_interval.tv_usec = 0;
    35.     timevalue.it_value.tv_sec = 5;
    36.     timevalue.it_value.tv_usec = 0;
    37.  
    38.     setitimer(ITIMER_REAL,&timevalue, NULL);
    39.     sigaction(SIGALRM,&act,NULL);
    40. //    oldact = signal(SIGINT,handle);
    41.  
    42.     while(1){
    43.   //      sleep(1);
    44.     }
    45.  
    46. }

    结果：

    五秒钟后启动定时器每秒输出一次。 

    使用SIGCHLD信号实现回收子进程

    SIGCHLD的产生条件

    1子进程终止时

    2子进程接收到SIGSTOP信号停止时

    3子进程处在停止态，接受到SIGCONT后唤醒时

    程序：（通过信号回收子进程，这样父进程不需要阻塞）

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7.  
    8. void handle(int sig){
    9.  
    10.     wait(NULL);
    11.     printf("Get sig =%d\n",sig);
    12.  
    13. }
    14.  
    15.  
    16. int main(){
    17.     pid_t pid;
    18.     struct sigaction act;
    19.     act.sa_handler = handle;
    20.     act.sa_flags = 0;
    21.     sigemptyset(&act.sa_mask);
    22.  
    23.     pid = fork();
    24.  
    25.     if(pid>0){
    26.         //wait(NULL);
    27.  
    28.         sigaction(SIGCHLD,&act,NULL);
    29.         while(1){
    30.             printf("this is father process\n");
    31.             sleep(1);
    32.         }
    33.  
    34.     }else if(pid==0){
    35.         sleep(5);
    36.         exit(0);
    37.     }
    38.  
    39.  
    40. }

    结果：

     

    信号集、信号屏蔽和阻塞

    （信号的三种方式其实都是一种软中断，打断了之前的程序运行，即便是忽略也进行了打断只不过什么都没做）

    有时候不希望在接到信号时就立即停止当前执行，去处理信号，同时也不希望忽略该信号，而是延时一段时间去调用信号处理函数。这种情况可以通过阻塞信号实现。

    信号的阻塞概念：信号的”阻塞“是一个开关动作，指的是阻止信号被处理，但不是阻止信号产生。

     

    信号的状态：

    信号递达（Delivery ）：实际信号执行的处理过程(3种状态：忽略，执行默认动作，捕获)

    信号未决（Pending）：从产生到递达之间的状态（挂起）

    信号集操作函数

    sigset_t set;  自定义信号集。  是一个32bit  64bit  128bit的数组。

    sigemptyset(sigset_t *set);     清空信号集

    sigfillset(sigset_t *set);   全部置1

    sigaddset(sigset_t *set, int signum);      将一个信号添加到集合中

    sigdelset(sigset_t *set, int signum);       将一个信号从集合中移除

    sigismember（const sigset_t *set，int signum); 判断一个信号是否在集合中。

    设定对信号集内的信号的处理方式(阻塞或不阻塞)

    #include

    int sigprocmask( int how, const sigset_t *restrict set, sigset_t *restrict oset );

    返回值：若成功则返回0，若出错则返回-1

    首先，若oset是非空指针，那么进程的当前信号屏蔽字通过oset返回。

    其次，若set是一个非空指针，则参数how指示如何修改当前信号屏蔽字。

    how可选用的值：（注意，不能阻塞SIGKILL和SIGSTOP信号）

    SIG_BLOCK ：   把参数set中的信号添加到信号屏蔽字中

    SIG_UNBLOCK： 从信号屏蔽字中删除参数set中的信号

    SIG_SETMASK： 把信号屏蔽字设置为参数set中的信号

    程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6.  
    7. void handle(int sig){
    8.     
    9.     printf("I get sig=%d\n",sig);
    10.  
    11. }
    12.  
    13. int main(){
    14.     
    15.     struct sigaction act;
    16.     act.sa_handler = handle;
    17.     sigemptyset(&act.sa_mask);
    18.     act.sa_flags = 0;
    19.     sigaction(SIGINT,&act,NULL);
    20.     sigset_t set;
    21.     sigemptyset(&set);
    22.     sigaddset(&set,SIGINT);
    23.  
    24.     sigprocmask(SIG_BLOCK,&set,NULL);
    25.     sleep(5);
    26.     sigprocmask(SIG_UNBLOCK,&set,NULL);
    27.  
    28.     while(1){
    29.         sleep(1);
    30.     }
    31.  
    32. }

    结果：

    按下ctrl+c等待五秒钟处理 

    int pause(void);

      进程一直阻塞，直到被信号中断，返回值：-1 并设置errno为EINTR

    函数行为：

    1如果信号的默认处理动作是终止进程，则进程终止，pause函数么有机会返回。

    2如果信号的默认处理动作是忽略，进程继续处于挂起状态，pause函数不返回

    3 如果信号的处理动作是捕捉，则调用完信号处理函数之后，pause返回-1。

    4 pause收到的信号如果被屏蔽，那么pause就不能被唤醒 

    int sigsuspend(const sigset_t *sigmask);

    功能：将进程的屏蔽字替换为由参数sigmask给出的信号集，然后挂起进程的执行

    参数：

    sigmask：希望屏蔽的信号

    程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6.  
    7. void handle(int sig){
    8.  
    9.     printf("I get sig=%d\n",sig);
    10.  
    11. }
    12.  
    13. void mytask(){
    14.     printf("My task start\n");
    15.     sleep(3);
    16.     printf("My task end\n");
    17.  
    18.  
    19. }
    20.  
    21.  
    22.  
    23. int main(){
    24.     struct sigaction act;
    25.     act.sa_handler = handle;
    26.     act.sa_flags = 0;
    27.     sigemptyset(&act.sa_mask);
    28.     sigaction(SIGINT,&act,NULL);
    29.     sigaction(SIGHUP,&act,NULL);
    30.     sigset_t set,set2;
    31.     sigemptyset(&set2);
    32.     sigaddset(&set,SIGHUP);
    33.     sigaddset(&set,SIGINT);
    34.     pause();
    35.     while(1){
    36.         sigprocmask(SIG_BLOCK,&set,NULL);
    37.         mytask();
    38.         //      sigprocmask(SIG_UNBLOCK,&set,NULL);
    39.         //      pause();
    40.         sigsuspend(&set2);
    41.     }
    42.     printf("After pause\n");
    43.     while(1){
    44.         sleep(1);
    45.     } 
    46.  
    47.  
    48. }

    如果不用sigsuspend函数使用被注释掉的两个语句，ctrl+c信号不会被pause接收到，因为被处理了。

    结果：

     八、消息队列

    概念：

    消息队列是System V IPC对象的一种（System 5）

     通过内核中的链表实现

     

    消息队列的使用：

    发送端：

    1 申请Key

    2打开/创建消息队列   msgget

    3向消息队列发送消息   msgsnd

    接收端：

    1打开/创建消息队列   msgget

    2从消息队列接收消息   msgrcv

    3 控制（删除）消息队列   msgctl

    打开/创建消息队列

     #include

     #include

     int msgget(key_t key, int msgflg);

      成功时返回消息队列的id，失败时返回EOF

      key 和消息队列关联的key  IPC_PRIVATE 或 ftok

      msgflg  标志位  IPC_CREAT|0666  IPC_CREAT：没有创建，有则打开。

    发送消息

    #include

     #include

     int msgsnd(int msgid, const void *msgp, size_t size,

                int msgflg);

      成功时返回0，失败时返回-1

      msgid   消息队列id

      msgp    消息缓冲区地址

      size    消息正文长度

      msgflg   标志位 0 或 IPC_NOWAIT

    msgflg:

    0：当消息队列满时，msgsnd将会阻塞，直到消息能写进消息队列

    IPC_NOWAIT：当消息队列已满的时候，msgsnd函数不等待立即返回

    消息格式：

    typedef struct{

    long msg_type;//第一个必须是long型代表消息的格式。

    char buf[128];//后面接着写随便定义

    }msgT;

    注意：

    1 消息结构必须有long类型的msg_type字段，表示消息的类型。

    2消息长度不包括首类型 long

    程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. typedef struct{
    7.     long msg_type;
    8.     char buf[128];
    9. }msgT;    
    10.  
    11. #define MSGLEN  (sizeof(msgT)-sizeof(long))
    12.  
    13. int main(){
    14.     key_t key;
    15.     int msgid;
    16.     int ret;
    17.     msgT msg;
    18.     key = ftok(".",100);
    19.     if(key<0){
    20.         perror("ftok");
    21.         return 0;
    22.     }
    23.     msgid = msgget(key,IPC_CREAT|0666);
    24.     if(msgid<0){
    25.         perror("msgget");
    26.         return 0;
    27.     }
    28.  
    29.     msg.msg_type = 1;
    30.     strcpy(msg.buf,"this msg type 1");
    31.     ret = msgsnd(msgid,&msg,MSGLEN,0);
    32.     if(ret<0){
    33.         perror("msgsnd");
    34.         return 0;
    35.     }    
    36. #if 0
    37.     msg.msg_type = 2;
    38.     strcpy(msg.buf,"this msg type 2");
    39.     ret = msgsnd(msgid,&msg,MSGLEN,0);
    40.     if(ret<0){
    41.         perror("msgsnd");
    42.         return 0;
    43.     }
    44.     msg.msg_type = 3;
    45.     strcpy(msg.buf,"this msg type 3");
    46.     ret = msgsnd(msgid,&msg,MSGLEN,0);
    47.     if(ret<0){
    48.         perror("msgsnd");
    49.         return 0;
    50.     }
    51.     msg.msg_type = 4;
    52.     strcpy(msg.buf,"this msg type 4");
    53.     ret = msgsnd(msgid,&msg,MSGLEN,0);
    54.     if(ret<0){
    55.         perror("msgsnd");
    56.         return 0;
    57.     }
    58.     msg.msg_type = 5;
    59.     strcpy(msg.buf,"this msg type 5");
    60.     ret = msgsnd(msgid,&msg,MSGLEN,0);
    61.     if(ret<0){
    62.         perror("msgsnd");
    63.         return 0;
    64.     }
    65. #endif
    66.  
    67.  
    68.  
    69. }

    结果：

     

    消息的接收：

    #include

     #include

     int msgrcv(int msgid, void *msgp, size_t size, long msgtype,

                       int msgflg);

      成功时返回收到的消息长度，失败时返回-1

      msgid   消息队列id

      msgp   消息缓冲区地址

      size   指定接收的消息长度

      msgtype   指定接收的消息类型  

      msgflg   标志位 

    msgtype：//发送类型没有等于零的都是大于零的

    msgtype=0：收到的第一条消息，任意类型。

    msgtype>0：收到的第一条 msg_type类型的消息。

    msgtype<0：接收类型等于或者小于msgtype绝对值的第一个消息。

    例子：如果msgtype=-4，只接受类型是1、2、3、4的消息

    msgflg：

    0：阻塞式接收消息

    IPC_NOWAIT：如果没有返回条件的消息调用立即返回，此时错误码为ENOMSG

    MSG_EXCEPT：与msgtype配合使用返回队列中第一个类型不为msgtype的消息

    程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. typedef struct{
    7.     long msg_type;
    8.     char buf[128];
    9. }msgT;    
    10.  
    11. #define MSGLEN  (sizeof(msgT)-sizeof(long))
    12. int main(){
    13.     
    14.     int msgid;
    15.     key_t key;
    16.     msgT msg;
    17.     int ret;
    18.     key = ftok(".",100);
    19.     if(key<0){
    20.         perror("ftok");
    21.         return 0;
    22.     }    
    23.     msgid = msgget(key,IPC_CREAT|0666);
    24.     if(msgid<0){
    25.         perror("msgget");
    26.         return 0;
    27.     }
    28.     int count=0;
    29.     while(1){
    30.         ret = msgrcv(msgid,&msg,MSGLEN,0,0);
    31.         if(ret<0){
    32.             perror("msgrcv");
    33.             return 0;
    34.         } 
    35.         count++;
    36.         if(count>3){
    37.             break;
    38.         }
    39.         printf("receiv msg type=%d,buf=%s\n",(int)msg.msg_type,msg.buf);
    40.     }
    41.  
    42.     ret = msgctl(msgid,IPC_RMID,NULL);
    43.     if(ret<0){
    44.         perror("msgctl");
    45.         return 0;
    46.     }    
    47.  
    48.  
    49. }

    结果：

    消息队列的控制

    #include

     #include

     int msgctl(int msgid, int cmd, struct msqid_ds *buf);

      成功时返回0，失败时返回-1

      msgid    消息队列id

      cmd    要执行的操作  IPC_STAT / IPC_SET / IPC_RMID（删除）

      buf   存放消息队列属性的地址

    九、信号灯/信号量（semaphore）

    概念：

    是不同进程间或一个给定进程内部不同线程间同步的机制。类似我们的

     

    PV操作概念：

    生产者和消费者场景

    Ｐ(Ｓ) 含义如下:

         if  (信号量的值大于0) { 

     申请资源的任务继续运行；

               信号量的值减一；

    } else {  

    申请资源的任务阻塞；

    }

    V(Ｓ) 含义如下:

         信号量的值加一；

         if (有任务在等待资源) {  

    唤醒等待的任务，让其继续运行

    }

    三种信号灯：

    Posix 有名信号灯

    Posix 无名信号灯 （linux只支持线程同步）

    System V 信号灯

    Posix 有名信号灯和无名信号灯使用：

     

    有名信号灯打开：

    sem_t *sem_open(const char *name, int oflag);

    sem_t *sem_open(const char *name, int oflag,mode_t mode, unsigned int value);

    参数：

    name：name是给信号灯起的名字

    oflag：打开方式，常用O_CREAT

    mode：文件权限。常用0666

    value：信号量值。二元信号灯值为1，普通表示资源数目

    信号灯文件位置：/dev/shm

    有名信号灯关闭

    int sem_close(sem_t *sem);

    有名信号灯的删除

    int sem_unlink(const char* name);

    读信号量：

    1. #include            /* For O_* constants */
    2. #include         /* For mode constants */
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. #include 
    11.  
    12.  
    13. void delsemfile(int sig){
    14.     sem_unlink("mysem_r");
    15.     exit(0);
    16.  
    17. }
    18.  
    19.  
    20. int main(){
    21.  
    22.    sem_t *sem_r,*sem_w;
    23.    key_t key;
    24.    int shmid;
    25.    char *shmaddr;
    26.    struct sigaction act;
    27.    act.sa_handler = delsemfile;
    28.    act.sa_flags = 0;
    29.    sigemptyset(&act.sa_mask);
    30.  
    31.    sigaction(SIGINT,&act,NULL);
    32.  
    33.  
    34.  
    35.    key = ftok(".",100);
    36.    if(key<0){
    37.        perror("ftok");
    38.        return 0;
    39.    }
    40.  
    41.    shmid = shmget(key,500,0666|IPC_CREAT);
    42.    if(shmid<0){
    43.        perror("shmget");
    44.        return 0;
    45.    }
    46.  
    47.    shmaddr = shmat(shmid,NULL,0);
    48.    
    49.    sem_r = sem_open("mysem_r",O_CREAT|O_RDWR,0666,0);
    50.    sem_w = sem_open("mysem_w",O_CREAT|O_RDWR,0666,1);
    51.  
    52.    while(1){
    53.         sem_wait(sem_r);
    54.         printf("%s\n",shmaddr);
    55.         sem_post(sem_w);
    56.    }
    57.  
    58. }
    59.

    写信号量：

    1. #include            /* For O_* constants */
    2. #include         /* For mode constants */
    3. #include 
    4.  
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. void delsemfile(int sig){
    12.     sem_unlink("mysem_w");
    13.     exit(0);
    14.  
    15. }
    16.  
    17. int main(){
    18.  
    19.  
    20.    sem_t *sem_r,*sem_w;
    21.    key_t key;
    22.    int shmid;
    23.    char *shmaddr;
    24.  
    25.    struct sigaction act;
    26.    act.sa_handler = delsemfile;
    27.    act.sa_flags = 0;
    28.    sigemptyset(&act.sa_mask);
    29.  
    30.    sigaction(SIGINT,&act,NULL);
    31.  
    32.    key = ftok(".",100);
    33.    if(key<0){
    34.        perror("ftok");
    35.        return 0;
    36.    }
    37.  
    38.    shmid = shmget(key,500,0666|IPC_CREAT);
    39.    if(shmid<0){
    40.        perror("shmget");
    41.        return 0;
    42.    }
    43.  
    44.    shmaddr = shmat(shmid,NULL,0);
    45.    
    46.    sem_r = sem_open("mysem_r",O_CREAT|O_RDWR,0666,0);
    47.    sem_w = sem_open("mysem_w",O_CREAT|O_RDWR,0666,1);
    48.  
    49.    while(1){
    50.         sem_wait(sem_w);
    51.         printf(">");
    52.         fgets(shmaddr,500,stdin);
    53.         sem_post(sem_r);
    54.    }
    55.  
    56. }
    57.

    结果：

     

    一定要加删除信号量操作，否则再次打开是失效的。只能手动来删除这个文件

     

     

    无名信号灯在Linux中只能进程间通信不能用于线程间

    无名信号灯初始化

    int sem_init(sem_t *sem, int shared, unsigned int value);

    参数：

    sem：需要初始化的信号灯变量

    shared: shared指定为0，表示信号量只能由初始化这个信号量的进程使用，不能在进程间使用,linux 不支持进程间同步。

    Value:信号量的值

    无名信号灯销毁

    int sem_destroy(sem_t* sem);

    信号灯P操作

    int sem_wait(sem_t *sem);

    获取资源，如果信号量为0，表示这时没有相应资源空闲，那么调用线程就将挂起，直到有空闲资源可以获取

    信号灯V操作

    int sem_post(sem_t *sem);

    释放资源，如果没有线程阻塞在该sem上，表示没有线程等待该资源，这时该函数就对信号量的值进行增1操作，表示同类资源多增加了一个。如果至少有一个线程阻塞在该sem上，表示有线程等待资源，信号量为0，这时该函数保持信号量为0不变，并使某个阻塞在该sem上的线程从sem_wait函数中返回

    注意：编译posix信号灯需要加pthread动态库。

    程序：

    1. #include            /* For O_* constants */
    2. #include         /* For mode constants */
    3. #include 
    4.  
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12.  
    13.  
    14. sem_t sem_r,sem_w;
    15. char *shmaddr;
    16. void destroysem(int sig){
    17. //    sem_unlink("mysem_w");
    18.    sem_destroy(&sem_r);
    19.    sem_destroy(&sem_w);
    20.    exit(0);
    21.  
    22. }
    23.  
    24. void *readmem(void *arg){
    25.     while(1){
    26.         sem_wait(&sem_r);
    27.         printf("%s\n",shmaddr);
    28.         sem_post(&sem_w);
    29.  
    30.     }
    31.  
    32. }
    33.  
    34.  
    35. int main(){
    36.  
    37.  
    38.    key_t key;
    39.    int shmid;
    40.  
    41.    struct sigaction act;
    42.    act.sa_handler = destroysem;
    43.    act.sa_flags = 0;
    44.    sigemptyset(&act.sa_mask);
    45.  
    46.    sigaction(SIGINT,&act,NULL);
    47.  
    48.    key = ftok(".",100);
    49.    if(key<0){
    50.        perror("ftok");
    51.        return 0;
    52.    }
    53.  
    54.    shmid = shmget(key,500,0666|IPC_CREAT);
    55.    if(shmid<0){
    56.        perror("shmget");
    57.        return 0;
    58.    }
    59.  
    60.    shmaddr = shmat(shmid,NULL,0);
    61.    
    62. //   sem_r = sem_open("mysem_r",O_CREAT|O_RDWR,0666,0);
    63. //   sem_w = sem_open("mysem_w",O_CREAT|O_RDWR,0666,1);
    64.    sem_init(&sem_r,0,0);
    65.    sem_init(&sem_w,0,1);
    66.  
    67.    pthread_t tid;
    68.    pthread_create(&tid,NULL,readmem,NULL);
    69.     
    70.    while(1){
    71.         sem_wait(&sem_w);
    72.         printf(">");
    73.         fgets(shmaddr,500,stdin);
    74.         sem_post(&sem_r);
    75.    }
    76.  
    77. }
    78.

    结果：

     

     

    System V 信号灯使用：

    int semget(key_t key, int nsems, int semflg);

    功能：创建/打开信号灯

    参数：key：ftok产生的key值（和信号灯关联的key值）

    　　　　　　   nsems：信号灯集中包含的信号灯数目

    　　　　　　   semflg：信号灯集的访问权限，通常为IPC_CREAT |0666

    返回值：成功：信号灯集ID ； 失败：-1

    int semop ( int semid, struct sembuf *opsptr, size_t nops);

    功能：对信号灯集合中的信号量进行P - V操作

    参数：semid：信号灯集ID

    　　　struct sembuf {

    　　　　short sem_num; // 要操作的信号灯的编号

    　　　　short sem_op;  // 1 : 释放资源，V操作

     // -1 : 分配资源，P操作 

    　　　　short sem_flg;  // 0（阻塞）,IPC_NOWAIT, SEM_UNDO

    　　　};//对某一个信号灯的操作，如果同时对多个操作，则需要定义这种结构体数组

    　　　nops: 要操作的信号灯的个数 ，1个

    返回值：成功 ：0 ； 失败：-1

    int semctl ( int semid, int semnum, int cmd…/*union semun arg*/);

    功能：信号灯集合的控制（初始化/删除）

    参数：semid：信号灯集ID

    　　　semnum: 要操作的集合中的信号灯编号

    　　　cmd：

    　　　GETVAL：获取信号灯的值，返回值是获得值

    　　　SETVAL：设置信号灯的值，需要用到第四个参数：共用体

    　　　IPC_RMID：从系统中删除信号灯集合

    返回值：成功 0 ； 失败 -1

    程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12.  
    13.  
    14. #define SEM_READ   0
    15. #define SEM_WRITE  1
    16.  
    17. union semun {
    18.    int val;
    19. };               
    20.  
    21. void Poperation(int semid,int semindex){
    22.    struct sembuf sbuf;
    23.    sbuf.sem_num =  semindex;
    24.    sbuf.sem_op = -1;
    25.    sbuf.sem_flg = 0;
    26.  
    27.    semop(semid,&sbuf,1);
    28.  
    29.  
    30. }
    31. void Voperation(int semid,int semindex){
    32.    struct sembuf sbuf;
    33.    sbuf.sem_num =  semindex;
    34.    sbuf.sem_op = 1;
    35.    sbuf.sem_flg = 0;
    36.               
    37.    semop(semid,&sbuf,1);
    38.  
    39.  
    40. }
    41.  
    42.  
    43.  
    44.  
    45. int main(){
    46.  
    47.     key_t key;
    48.     char *shmaddr;
    49.     int semid,shmid;
    50.     key = ftok(".",100);
    51.     if(key<0){
    52.         perror("ftok");
    53.         return 0;
    54.     }
    55.     
    56.     semid = semget(key,2,IPC_CREAT |0666);
    57.     if(semid<0){
    58.         perror("semget");
    59.         return 0;
    60.     }
    61.     shmid = shmget(key,500,IPC_CREAT |0666);
    62.     shmaddr = shmat(shmid,NULL,0);
    63.     union semun mysem;
    64.     mysem.val = 0;
    65.     semctl(semid,SEM_READ,SETVAL,mysem);
    66.     mysem.val = 1;
    67.     semctl(semid,SEM_WRITE,SETVAL,mysem);
    68.  
    69.     pid_t pid;
    70.     pid = fork();
    71.     if(pid<0){
    72.         perror("fork");
    73.         shmctl(shmid,IPC_RMID,NULL);
    74.         semctl(semid,0,IPC_RMID);
    75.         exit(-1);
    76.     }else if(pid == 0){
    77.         while(1){
    78.             Poperation(semid,SEM_READ);
    79.             printf("%s\n",shmaddr);
    80.  
    81.             Voperation(semid,SEM_WRITE);
    82.  
    83.         }
    84.  
    85.  
    86.     }else{
    87.         while(1){
    88.             Poperation(semid,SEM_WRITE);
    89.             printf(">");
    90.             fgets(shmaddr,32,stdin);
    91.  
    92.             Voperation(semid,SEM_READ);
    93.  
    94.         }
    95.  
    96.  
    97.  
    98.     }
    99.  
    100. }

    结果：

     

  • 相关阅读:
    云原生之nacos架构一览解读
    【TI毫米波雷达笔记】IWR6843AOPEVM-G+DCA1000EVM的mmWave Studio数据读取、配置及避坑
    【ARMv9 DSU-120 系列 3 -- 系统控制寄存器】
    Python问题：树的镜面映射
    散列算法比较：MD5、SHA1、SHA256有哪些区别
    leetcode 754. 到达终点数字
    torch.zeros
    PyQt5开发笔记：1.环境搭建与界面美化
    【 Git 和 SVN 的区别】
    【PTA】输出学生成绩
  • 原文地址：https://blog.csdn.net/qq_52479948/article/details/127813140