• C语言：详细介绍了六种进程间通讯方式（还有一种socket在主页关于socket的介绍里面有详细介绍，欢迎观看）

    一.无名管道

    1.1无名管道的原理

    无名管道只能用于亲缘间进程的通信，无名管道的大小是64K。无名管道是内核空间实现的机制。

    1.2功能

     1) Pipe()创建一个管道，这是一个单向的数据通道，可用于进程间通信。

    2)数组pipefd用于返回两个指向管道末端的文件描述符。

    3)Pipefd[0]指的是管道的读端。Pipefd[1]指的是管道的写入端,写入管道的写入端数据由内核进行缓冲（64k），直到从管道的读取端读取为止。

    1.3无名管道通信特点

    1.只能用于亲缘间进程的通信

    2.无名管道数据半双工的通信的方式

    ​ 单工 ： A -------------->B

    ​ 半双工 : 同一时刻 A----->B B------>A

    ​ 全双工 : 同一时刻 A<---->B

    3.无名管道的大小是64K

    4.无名管道不能够使用lseek函数

    5.读写的特点

    如果读端存在写管道：有多少写多少，直到写满为止（64k）写阻塞

    如果读端不存写管道，管道破裂（SIGPIPE） (可以通过gdb调试看现象)

    如果写端存在读管道：有多少读多少，没有数据的时候阻塞等待

    如果写端不存在读管道：有多少读多少，没有数据的时候立即返回

    1.4无名管道的实例

    1. #include 
    2. #include 
    3. #include 
    4. #include  
    5. #include 
    6. #include 
    7. #include 
    8. #define ERROR(msg) do{\
    9.     printf("%s %s %d\n", __FILE__, __func__, __LINE__);\
    10.     printf(msg);\
    11.     exit(-1); \
    12. }while(0)
    13.  
    14. int main(int argc, char const *argv[])
    15. {
    16.     pid_t pid;
    17.     int num[2];
    18.     char buff[128] = {0};
    19.  
    20.     if (pipe(num)){
    21.         ERROR("pipe error");
    22.     }
    23.  
    24.     if ((pid = fork()) == -1){
    25.         ERROR("fork error");
    26.     }else if(pid == 0){
    27.         close(num[0]);
    28.         while (1){
    29.             memset(buff, 0, sizeof(buff));
    30.             printf("请输入您要输入的数值>>");
    31.             fgets(buff, sizeof(buff), stdin);
    32.             buff[strlen(buff) -1] = '\0';
    33.             write(num[1], buff, strlen(buff));
    34.  
    35.             if (!strncmp(buff, "quit", 4)){
    36.                 break;
    37.             }
    38.  
    39.         }
    40.         close(num[1]);
    41.         exit(EXIT_SUCCESS);
    42.     }else{
    43.         close(num[1]);
    44.         while (1){
    45.             memset(buff, 0, sizeof(buff));
    46.             read(num[0], buff, sizeof(buff));
    47.  
    48.             if (!strncmp(buff, "quit", 4)){
    49.                 break;
    50.             }
    51.             printf("%s\n",buff);
    52.         }   
    53.         close(num[0]);
    54.         wait(NULL);
    55.     }
    56.  
    57.     return 0;
    58. }

    二.有名管道

    2.1有名管道的原理

    1)可以用于亲缘间进程的通信，也可以用于非亲缘间的进程的通信。

    2)有名管道会创建一个文件，需要通信的进程打开这个文件，产生文件描述符后就可以通信了，有名管道的文件存在内存上。

    3)有名管道的大小也是64K,也不能使用lseek函数

    2.2有名管道的特点

    1.可以用于任意进程间的通信

    2.有名管道数据半双工的通信的方式

    3.有名管道的大小是64K

    4.有名管道不能够使用lseek函数

    5.读写的特点

    如果读端存在写管道：有多少写多少，直到写满为止（64k）写阻塞

    如果读端不存写管道

    ​ 1.读权限没有打开，写端在open的位置阻塞

    ​ 2.读端打开后关闭，管道破裂（SIGPIPE） (可以通过gdb调试看现象)

    如果写端存在读管道：有多少读多少，没有数据的时候阻塞等待

    如果写端不存在读管道

    ​ 1.写权限没有打开，读端在open的位置阻塞

    ​ 2.写端打开后关闭，有多少读多少，没有数据的时候立即返回

    2.3有名管道实例：

    mkfifo文件:

    1. #include 
    2. #include 
    3. #define ERROR(msg) do{\
    4.     printf("%s %s %d\n", __FILE__, __func__, __LINE__);\
    5.     printf(msg);\
    6.     exit(-1); \
    7. }while(0)
    8.  
    9. int main(int argc, char const *argv[])
    10. {
    11.     if (mkfifo("./fifo",0666)){
    12.         ERROR("mkfifo error");
    13.     }
    14.  
    15.     //有名管道没有阻塞，手动加一个阻塞
    16.     getchar();
    17.  
    18.     system("rm ./fifo -rf");
    19.     
    20.     return 0;
    21. }

    write文件：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #define ERROR(msg) do{\
    10.     printf("%s %s %d\n", __FILE__, __func__, __LINE__);\
    11.     printf(msg);\
    12.     exit(-1); \
    13. }while(0)
    14.  
    15. int main(int argc, char const *argv[])
    16. {
    17.     int fd;
    18.     char buff[128] = {0};
    19.     if ((fd = open("./fifo",O_WRONLY)) == -1){
    20.         ERROR("open fifo error\n");
    21.     }
    22.  
    23.     while(1){
    24.         printf("input >");
    25.         fgets(buff, sizeof(buff), stdin);
    26.         buff[strlen(buff) - 1] = '\0';
    27.  
    28.         write(fd, buff, strlen(buff));
    29.         if(!strncmp("quit",buff,4))break;
    30.     }
    31.     close(fd);
    32.     return 0;
    33. }

    read文件：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. #define ERROR(msg)                                          \
    11.     do                                                      \
    12.     {                                                       \
    13.         printf("%s %s %d\n", __FILE__, __func__, __LINE__); \
    14.         printf(msg);                                        \
    15.         exit(-1);                                           \
    16.     } while (0)
    17.  
    18. int main(int argc, char const *argv[])
    19. {
    20.     int fd;
    21.     char buff[128] = {0};
    22.     if ((fd = open("./fifo", O_RDONLY)) == -1)
    23.     {
    24.         ERROR("open error");
    25.     }
    26.  
    27.     while (1){
    28.         memset(buff, 0, sizeof(buff));
    29.         read(fd, buff, sizeof(buff));
    30.         if (!strncmp("quit",buff,4)){
    31.             break;
    32.         }
    33.  
    34.         printf("%s\n",buff);
    35.     }
    36.     close(fd);
    37.     return 0;
    38. }

    三.信号

    3.1信号的概念

    信号是中断的一种软件模拟，中断是基于硬件实现的，信号是基于linux内核实现的。

    用户可以给进程发信号，进程可以给进程发信号，内核也可以给进程发信号。进程对

    信号的处理方式有三种：捕捉，忽略，默认

    3.2发送信号的函数

    1. int raise(int sig);
    2. 功能：给自己（进程或者线程）发信号
    3. 参数：
    4.     @sig:信号号
    5. 返回值：成功返回0，失败返回非0
    6.  
    7. int kill(pid_t pid, int sig);
    8. 功能：给进程发信号
    9. 参数：
    10.     @pid:进程号
    11.         pid > 0 :给pid对应的进程发信号
    12.         pid = 0 :给同组的进程发信号
    13.         pid = -1:给所有的有权限操作的进程发送信号，init进程除外
    14.         pid < -1:给-pid对应的同组的进程发信号       
    15.     @sig:信号号
    16. 返回值：成功返回0，失败返回-1置位错误码

    3.2常用的信号

     

    1.在上述的信号中只有SIGKILL和SIGSTOP两个信号不能被捕捉也不能被忽略

    2.SIGCHLD,当子进程结束的时候，父进程收到这个SIGCHLD的信号

    3.3实例：

    3.3.1捕捉ctrl+c

    1. #include 
    2. #include 
    3. #include 
    4. #define ERROR(msg) do{\
    5.     printf("%s %s %d\n", __FILE__, __func__, __LINE__);\
    6.     printf(msg);\
    7.     exit(-1); \
    8. }while(0)
    9.  
    10. void handle(int num)
    11. {
    12.     if (num == SIGINT){
    13.         printf("我收到一个ctrl+c的信号\n");
    14.     }
    15. }
    16.  
    17. int main(int argc, char const *argv[])
    18. {
    19.     //捕捉
    20.     if (signal(SIGINT, handle) == SIG_ERR){
    21.         ERROR("register signal error");
    22.     }
    23.     //忽略
    24.     if (signal(SIGINT,SIG_IGN) == SIG_ERR){
    25.         ERROR("register signal error");
    26.     }
    27.     //默认
    28.     if (signal(SIGINT,SIG_DFL) == SIG_ERR){
    29.         ERROR("register signale");
    30.     }
    31.  
    32.  
    33.     while(1);
    34.     return 0;
    35. }

    3.3.2捕捉管道破裂的消息：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. #define ERROR(msg) do{\
    8.     printf("%s %s %d\n", __FILE__, __func__, __LINE__);\
    9.     printf(msg);\
    10.     exit(-1); \
    11. }while(0)
    12.  
    13. void handle(int num)
    14. {
    15.     if (num == SIGPIPE){
    16.         printf("捕捉到一条管道破裂的消息\n");
    17.     }
    18. }
    19.  
    20. int main(int argc, char const *argv[])
    21. {
    22.     int num[2];
    23.     char buff[32] = "123";
    24.  
    25.     if(pipe(num)){
    26.         ERROR("pipe error");
    27.     }
    28.  
    29.     if (signal(SIGPIPE,handle) == SIG_ERR){
    30.         ERROR("signal error");
    31.     }
    32.  
    33.     close(num[0]);
    34.  
    35.     write(num[1],buff,strlen(buff));
    36.     return 0;
    37. }

    3.3.3阻塞等待为子进程回收资源：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. void signal_handle(int signo)
    8. {
    9.     printf("我是父进程，收到了子进程退出的信号，为它回收资源\n");
    10.     waitpid(-1,NULL,WNOHANG); //非阻塞方式回收资源
    11.     printf("为子进程回收资源成功\n");
    12.     raise(SIGKILL);  //给父进程发送信号，结束父进程
    13. }
    14.  
    15. int main(int argc,const char * argv[])
    16. {
    17.     pid_t pid;
    18.  
    19.     pid = fork();
    20.     if(pid == -1){
    21.         ERROR("fork error");
    22.     }else if(pid == 0){
    23.         sleep(5);
    24.         printf("子进程执行结束了\n");
    25.         exit(EXIT_SUCCESS);
    26.     }else{
    27.         if(signal(SIGCHLD,signal_handle)==SIG_ERR)
    28.             ERROR("signal error");
    29.  
    30.         while(1);
    31.     }
    32.     
    33.     return 0;
    34. }

    3.3.4用arlarm实现一个斗地主机制

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. #define ERROR(msg) do{\
    7.     printf("%s %s %d\n", __FILE__, __func__, __LINE__);\
    8.     printf(msg);\
    9.     exit(-1); \
    10. }while(0)
    11.  
    12. void handle(int num)
    13. {
    14.     if (num == SIGALRM){
    15.         printf("自动出牌\n");
    16.     }
    17.     alarm(3);
    18. }
    19.  
    20. int main(int argc, char const *argv[])
    21. {
    22.     char ch;
    23.     if (signal(SIGALRM,handle) == SIG_ERR){
    24.         ERROR("signale error");
    25.     }
    26.     
    27.     alarm(3);
    28.  
    29.     while (1){
    30.         printf("请输入您要出的牌>>");
    31.         ch = getchar();
    32.         getchar();
    33.         printf("%c\n",ch);
    34.         alarm(3);
    35.     }
    36.     return 0;
    37. }

    四.IPC进程间通信

    4.1IPC进程间通信的种类

    （1）消息队列

    （2）共享内存

    （3）信号灯集

    4.2查看IPC进程间通信的命令

    4.2.1查看

    ipcs -q //查看消息队列的命令

    ipcs -m //查看共享内存的命令

    ipcs -s //查看信号灯集的命令

    4.2.2删除ipc的命令

    ipcrm -q msqid //删除消息队列命令

    ipcrm -m shmid //删除共享内存命令

    ipcrm -s semid //删除信号灯集的命令

    4.3消息队列

    4.3.1消息队列的原理

    消息队列也是借助内核实现的，A进程将消息放到消息队列中，队列中的消息

    有消息的类型和消息的正文。B进程可以根据想取的消息的类型从消息队列中

    将消息读走。消息队列默认的大小是16384个字节。如果消息队列中的消息满了，

    A进程还想往队列中发消息，此时A进程阻塞。

    4.3.2IPC进程间通信键值的获取

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #define ERROR(msg) do{\
    9.     printf("%s %s %d\n", __FILE__, __func__, __LINE__);\
    10.     printf(msg);\
    11.     exit(-1); \
    12. }while(0)
    13.  
    14. int main(int argc, char const *argv[])
    15. {
    16.     key_t key;
    17.     struct stat st;
    18.  
    19.    if ((key = ftok("/home/linux",'w')) == -1){
    20.         ERROR("ftok error");
    21.    }
    22.  
    23.    printf("key=%#x\n",key);
    24.  
    25.    if (stat("/home/linux",&st)){
    26.         ERROR("stat error");
    27.    }
    28.  
    29.    printf("pro_id=%#x,devno=%#lx,ino=#=%#lx\n",'w',st.st_dev,st.st_ino);
    30.     return 0;
    31. }

    结果图：

    4.3.3消息队列的实例：(不关注类型的)

    头文件:

    1. #ifndef __MYHEAD_H__
    2. #define __MYHEAD_H__
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12.  
    13. #define  PRINT_ERR(msg) do{\
    14.     printf("%s %s %d\n", __FILE__, __func__, __LINE__);\
    15.     printf(msg);\
    16.     exit(-1); \
    17. }while(0)
    18.  
    19.  
    20. #define MSGSIZE (sizeof(msg_t)-sizeof(long))
    21.  
    22. typedef  struct mubuf{
    23.     long mtype;
    24.     char text[512];
    25. }msg_t;
    26.  
    27. #endif

    发送方：

    1. #include "myhead.h"
    2.  
    3. int main(int argc, char const *argv[])
    4. {
    5.     key_t key;
    6.     int msqid;
    7.     msg_t msg ={
    8.         .mtype = 100,
    9.     };
    10.  
    11.      if((key = ftok("/home/linux/",'r'))==-1)
    12.         PRINT_ERR("ftok get key error");
    13.  
    14.     if((msqid = msgget(key,IPC_CREAT|0666))==-1)
    15.         PRINT_ERR("create msg queue error");
    16.  
    17.     while (1){
    18.         memset(msg.text,0,sizeof(msg.text));
    19.         fgets(msg.text,MSGSIZE,stdin);
    20.         msg.text[strlen(msg.text) - 1] = '\0';
    21.  
    22.         msgsnd(msqid, &msg, MSGSIZE, 0);
    23.  
    24.         if (!strncmp(msg.text,"quit",4)){
    25.             break;
    26.         }
    27.     }
    28.  
    29.     msgctl(msqid, IPC_RMID, NULL);
    30.     return 0;
    31. }

    接受方：

    1. #include "myhead.h"
    2.  
    3. int main(int argc, char const *argv[])
    4. {
    5.     key_t key;
    6.     int msgqid;
    7.     msg_t msg;
    8.  
    9.     if ((key = ftok("/home/linux",'r')) == -1){
    10.         PRINT_ERR("ftok error");
    11.     }
    12.  
    13.     if ((msgqid = msgget(key, IPC_CREAT|0666)) == -1){
    14.         PRINT_ERR("msgget error");
    15.     }
    16.  
    17.     while (1){
    18.         memset(msg.text, 0, sizeof(msg.text));
    19.         msgrcv(msgqid, &msg, MSGSIZE,0,0);
    20.  
    21.         if (!strncmp("quit",msg.text,4)){
    22.             break;
    23.         }
    24.  
    25.         printf("%s\n",msg.text);
    26.     }
    27.  
    28.     msgctl(msgqid,IPC_RMID,NULL);
    29.     return 0;
    30. }
    31.

    4.3.4消息队列的实例：(关注类型的)

    头文件：

    1. #ifndef __MSGQUE_H__
    2. #define __MSGQUE_H__
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12.  
    13. typedef struct msgbuf {
    14.     long id;
    15.     char name[30];
    16.     char sex;
    17.     int age;
    18. }msg_t;
    19.  
    20. #define MSGSIZE (sizeof(msg_t)-sizeof(long))
    21.  
    22. #endif

    发送方：

    1. #include "msgqueue.h"
    2. #include 
    3.  
    4. int main(int argc, const char* argv[])
    5. {
    6.     key_t key;
    7.     int msqid;
    8.  
    9.     if ((key = ftok("/home/linux/", 'r')) == -1)
    10.         PRINT_ERR("ftok get key error");
    11.  
    12.     if ((msqid = msgget(key, IPC_CREAT | 0666)) == -1)
    13.         PRINT_ERR("create msg queue error");
    14.  
    15.     msg_t m1 = {
    16.         .id = 1,
    17.         .name = "zhangsan",
    18.         .sex = 'm',
    19.         .age = 30,
    20.     };
    21.     msgsnd(msqid, &m1, MSGSIZE, 0);
    22.     msg_t m2 = {
    23.         .id = 2,
    24.         .name = "lisi",
    25.         .sex = 'w',
    26.         .age = 18,
    27.     };
    28.     msgsnd(msqid, &m2, MSGSIZE, 0);
    29.     msg_t m3 = {
    30.         .id = 3,
    31.         .name = "wangwu",
    32.         .sex = 'm',
    33.         .age = 22,
    34.     };
    35.     msgsnd(msqid, &m3, MSGSIZE, 0);
    36.  
    37.  
    38.     // msgctl(msqid, IPC_RMID, NULL);
    39.  
    40.     return 0;
    41. }

    接受方：

    1. #include "msgqueue.h"
    2.  
    3. int main(int argc, const char* argv[])
    4. {
    5.     key_t key;
    6.     int msqid;
    7.     msg_t msg;
    8.  
    9.  
    10.     if ((key = ftok("/home/linux/", 'r')) == -1)
    11.         PRINT_ERR("ftok get key error");
    12.  
    13.     if ((msqid = msgget(key, IPC_CREAT | 0666)) == -1)
    14.         PRINT_ERR("create msg queue error");
    15.  
    16.  
    17.     memset(&msg, 0, sizeof msg);
    18.     msgrcv(msqid, &msg, MSGSIZE, atoi(argv[1]), 0);
    19.     printf("id=%ld,name=%s,sec=%c,age=%d\n",msg.id,msg.name,msg.sex,msg.age);
    20.  
    21.     // msgctl(msqid, IPC_RMID, NULL);
    22.  
    23.     return 0;
    24. }

    结果图：

     4.4共享内存：

    4.4.1原理：

    共享内存：在内核空间创建共享内存，让用户的A和B进程都能够访问到。通过这块内存

    进行数据的传递。共享内存所有的进程间通信中效率最高的方式（不需要来回拷贝数据），共享内存的大小为 4k整数倍。

    4.4.2实例：

    接受方：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #define  PRINT_ERR(msg) do{\
    9.     printf("%s %s %d\n", __FILE__, __func__, __LINE__);\
    10.     printf(msg);\
    11.     exit(-1); \
    12. }while(0)
    13.  
    14. int main(int argc, char const *argv[])
    15. {
    16.     key_t key;
    17.     int shmid;
    18.     char* over;
    19.  
    20.     if ((key = ftok("/home/linux", 'r')) == -1){
    21.         PRINT_ERR("ftok error");
    22.     }
    23.  
    24.     if ((shmid = shmget(key, 4096, IPC_CREAT|0666)) == -1){
    25.         PRINT_ERR("shemget error");
    26.     }
    27.  
    28.     if ((over = shmat(shmid, NULL, 0)) == (void*)-1){
    29.         PRINT_ERR("shmat error");
    30.     }
    31.  
    32.     while (1){
    33.         if (!strncmp("quit", over, 4))break;
    34.         getchar();
    35.  
    36.         printf("%s\n",over);
    37.     }
    38.  
    39.     if (shmdt(over)){
    40.         PRINT_ERR("shmdt error");
    41.     }
    42.  
    43.     shmctl(shmid,IPC_RMID,NULL);
    44.     return 0;
    45. }

    发送方：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #define  PRINT_ERR(msg) do{\
    9.     printf("%s %s %d\n", __FILE__, __func__, __LINE__);\
    10.     printf(msg);\
    11.     exit(-1); \
    12. }while(0)
    13.  
    14. int main(int argc, char const *argv[])
    15. {
    16.     key_t key;
    17.     int shmid;
    18.     char* over;
    19.  
    20.     if ((key = ftok("/home/linux", 'r')) == -1){
    21.         PRINT_ERR("ftok error");
    22.     }
    23.  
    24.     if ((shmid = shmget(key, 4096, IPC_CREAT|0666)) == -1){
    25.         PRINT_ERR("shmget error\n");
    26.     }
    27.  
    28.     if ((over = shmat(shmid, NULL, 0)) == (void*)-1){
    29.         PRINT_ERR("shmat error\n");
    30.     }
    31.  
    32.     while (1){
    33.         printf("请输入>>");
    34.         fgets(over,4096,stdin);
    35.         over[strlen(over) - 1] = '\0';
    36.  
    37.         if (!strncmp("quit",over,4)){
    38.             break;
    39.         }
    40.     }
    41.  
    42.     if (shmdt(over)){
    43.         PRINT_ERR("shmdt error\n");
    44.     }
    45.  
    46.     shmctl(shmid,IPC_RMID,NULL);
    47.     return 0;
    48. }

    4.5信号灯集合

    4.1信号量的原理

    信号量：又叫信号灯集，它是实现进程间同步的机制。在一个信号灯集中可以有

    很多的信号灯，这些信号灯它们的工作相关不干扰。一般使用的时候使用的是二值

    信号灯。

    4.2信号灯集函数的封装

    sem.h

    1. #ifndef __SEM_H__
    2. #define __SEM_H__
    3.  
    4. int mysem_init(int nsems);
    5. int P(int semid, int semnum);
    6. int V(int semid, int semnum);
    7. int sem_del(int semid);
    8.  
    9. #endif

    sem.c

    1. #include 
    2.  
    3. union semun {
    4.     int val; /* Value for SETVAL */
    5.     struct semid_ds* buf; /* Buffer for IPC_STAT, IPC_SET */
    6. };
    7.  
    8. int semnum_init_value(int semid, int which, int value)
    9. {
    10.     union semun sem = {
    11.         .val = value,
    12.     };
    13.     if (semctl(semid, which, SETVAL, sem) == -1)
    14.         PRINT_ERR("semctl int value error");
    15.     return 0;
    16. }
    17.  
    18. //初始化信号灯集
    19. int mysem_init(int nsems)
    20. {
    21.     key_t key;
    22.     int semid;
    23.     // 1.通过ftok获取键值
    24.     if ((key = ftok("/home/linux/", 'g')) == -1)
    25.         PRINT_ERR("get key error");
    26.     // 2.如果不选择就创建信号灯集，如果存在返回已存在的错误
    27.     if ((semid = semget(key, nsems, IPC_CREAT | IPC_EXCL | 0666)) == -1) {
    28.         if (errno == EEXIST) {
    29.             //如果已存在，这里调用semget，直接返回semid
    30.             semid = semget(key, nsems, IPC_CREAT | 0666);
    31.         } else {
    32.             PRINT_ERR("create sem error");
    33.         }
    34.     } else {
    35.         // 3.初始化信号灯集中的信号灯
    36.         for (int i = 0; i < nsems; i++) {
    37.             semnum_init_value(semid, i, !i);
    38.         }
    39.     }
    40.  
    41.     return semid;
    42. }
    43.  
    44. //申请资源
    45. int P(int semid, int semnum)
    46. {
    47.     struct sembuf buf = {
    48.         .sem_num = semnum,
    49.         .sem_op = -1,
    50.         .sem_flg = 0,
    51.     };
    52.  
    53.     if (semop(semid, &buf, 1))
    54.         PRINT_ERR("request resource error");
    55.  
    56.     return 0;
    57. }
    58. //释放资源
    59. int V(int semid, int semnum)
    60. {
    61.     struct sembuf buf = {
    62.         .sem_num = semnum,
    63.         .sem_op = 1,
    64.         .sem_flg = 0,
    65.     };
    66.  
    67.     if (semop(semid, &buf, 1))
    68.         PRINT_ERR("free resource error");
    69.  
    70.     return 0;
    71. }
    72. //删除信号灯集
    73. int sem_del(int semid)
    74. {
    75.     semctl(semid,0,IPC_RMID);
    76. }

    4.3用信号灯集实现进程同步

    写端：

    1. #include 
    2. #include "sem.h"
    3.  
    4. int main(int argc, const char* argv[])
    5. {
    6.     key_t key;
    7.     int shmid,semid;
    8.     char* waddr;
    9.     //0.信号量的初始化
    10.     semid = mysem_init(2);
    11.     if(semid == -1){
    12.         printf("sem init error");
    13.         return -1;
    14.     }
    15.     // 1.获取key
    16.     if ((key = ftok("/home/linux", 'p')) == -1)
    17.         PRINT_ERR("get key error");
    18.     // 2.创建共享内存
    19.     if ((shmid = shmget(key, 4096, IPC_CREAT | 0666)) == -1)
    20.         PRINT_ERR("create share memory error");
    21.     // 3.将共享内存映射到用户空间
    22.     if ((waddr = shmat(shmid, NULL, 0)) == (void*)-1)
    23.         PRINT_ERR("shmat error");
    24.     printf("waddr = %p\n", waddr);
    25.     // 4.写操作
    26.     while (1) {
    27.         P(semid,0);
    28.         printf("input > ");
    29.         fgets(waddr, 4096, stdin);
    30.         waddr[strlen(waddr) - 1] = '\0';
    31.         if (strncmp(waddr, "quit", 4) == 0)
    32.             break;
    33.         V(semid,1);
    34.     }
    35.     // 5.取消地址映射
    36.     if (shmdt(waddr))
    37.         PRINT_ERR("shmdt error");
    38.  
    39.     // 6.删除共享内存
    40.     if (shmctl(shmid, IPC_RMID, NULL))
    41.         PRINT_ERR("shmrm error");
    42.     //7.删除信号量
    43.     sem_del(semid);
    44.     return 0;
    45. }

    读端口：

    1. #include "sem.h"
    2. #include 
    3. int main(int argc, const char* argv[])
    4. {
    5.     key_t key;
    6.     int shmid, semid;
    7.     char* raddr;
    8.     // 0.信号量的初始化
    9.     semid = mysem_init(2);
    10.     if (semid == -1) {
    11.         printf("sem init error");
    12.         return -1;
    13.     }
    14.     // 1.获取key
    15.     if ((key = ftok("/home/linux", 'p')) == -1)
    16.         PRINT_ERR("get key error");
    17.     // 2.创建共享内存
    18.     if ((shmid = shmget(key, 4096, IPC_CREAT | 0666)) == -1)
    19.         PRINT_ERR("create share memory error");
    20.  
    21.     // 3.将共享内存映射到用户空间
    22.     if ((raddr = shmat(shmid, NULL, 0)) == (void*)-1)
    23.         PRINT_ERR("shmat error");
    24.  
    25.     printf("waddr = %p\n", raddr);
    26.     // 4.读操作
    27.     while (1) {
    28.         P(semid,1);
    29.         printf("raddr = %s\n", raddr);
    30.         if (strncmp(raddr, "quit", 4) == 0)
    31.             break;
    32.         V(semid,0);
    33.     }
    34.     // 5.取消地址映射
    35.     if (shmdt(raddr))
    36.         PRINT_ERR("shmdt error");
    37.  
    38.     // 6.删除共享内存
    39.     shmctl(shmid, IPC_RMID, NULL);
    40.  
    41.     //7.删除信号量
    42.     sem_del(semid);
    43.     return 0;
    44. }

  • 相关阅读:
    【Linux内核代码分析1】Linux时间子系统及HRTIMER实现
    【如何在Ubuntu 20.04系统上安装和使用Wine教程】
    堆排序--C语言版
    PX4模块设计之三十七：MulticopterRateControl模块
    基于SSM的校园车辆管理系统设计与实现
    程序员，在北上广深杭赚够100万，就逃回二三四线城市生活，靠谱吗？
    Pr：导出设置之音频
    nuxt.js服务端渲染项目性能优化总结
    Qt入门学习及GUI编程基础教程
    Docker的入门基础和使用
  • 原文地址：https://blog.csdn.net/a2998658795/article/details/126328709