• Linux C进程间通信（IPC）

    概述

    每个进程有独立的进程空间：

    好处————安全

    缺点：开销大（独立的地址空间）；进程的通信更加困难（对其他进程的操作开销也大）

    广义上的进程间通信：

    A进程写给文件/数据库，B进程从文件/数据库里读取

     狭义上的真正的“进程间通信”

    1. 管道
    2. 信号
    3. 消息队列
    4. 共享内存
    5. 信号量
    6. 套接字
       

    进程间通信的原理

    尽管进程空间是各自独立的，相互之间没有任何可以共享的空间，但至少还有一个共享的，那就是OS，因为甭管运行有多少个进程，但是它们共用OS只有一个。
    既然大家共用的是同一个OS，那么显然，所有的进程可以通过大家都共享第三方OS来实现数据的转发。
    因此进程间通信的原理就是，OS作为所有进程共享的第三万，会提供相应的机制，以实现进程间数据的转发，达到数据共享的目的

    信号

    信号是一种向进程发送通知，告诉其某件事情发生了的一种简单通信机制

    古老，应用广泛；        仅做通知，不做数据传输；        本质上是整数值（SIG开头）；

    信号列表

    信号的产生

    另一个进程发生信号；内核发送信号；底层硬件发送信号

    信号发送

    ps命令：查看进程的信息

    终端

    kill命令：kill -s 《signal》 《pid》

    程序中给一个进程发信号

    给当前进程发信号

    raise
     alarm

    abort
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. int main()
    6. {
    7.     // kill(-1, SIGINT);//给所有进程发出信号（SIGINT是终止信号）
    8.     
    9.     // raise(SIGINT);   //给当前进程发出终止信号
    10.     
    11.     alarm(5);           //定时器到期，操作系统将发送 SIGALRM 信号给进程。
    12.                         //默认情况下，如果进程没有对 SIGALRM 信号进行处理，它将终止进程的执行
    13.     
    14.     //while(1);
    15.     pause();            //挂起当前进程（相比于while（1）这种cpu消耗性更节约资源）
    16.     
    17.  
    18.     abort（）；          //错误地退出
    19.     
    20.     return 0;
    21. }

    信号的处理方式

    1.默认处理；                2.忽略；                3.执行用户需要执行的操作（捕获）；

    信号处理API

    signal

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. int main()
    6. {
    7.     // kill(-1, SIGINT);//给所有进程发出信号（SIGINT是终止信号）
    8.     
    9.     // raise(SIGINT);   //给当前进程发出终止信号
    10.     
    11.     alarm(5);           //定时器到期，操作系统将发送 SIGALRM 信号给进程。
    12.                         //默认情况下，如果进程没有对 SIGALRM 信号进行处理，它将终止进程的执行
    13.     
    14.     //while(1);
    15.     pause();            //挂起当前进程（相比于while（1）这种cpu消耗性更节约资源）；直到有一个信号来
    16.    
    17.     return 0;
    18. }
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. void handler(int sig)       // 信号处理函数
    7. {
    8.     if (sig == SIGALRM)     // 可以判断是哪个信号调用的处理函数
    9.     {
    10.         printf("handler with alarm\n");
    11.     }
    12.     else if (sig == SIGINT)
    13.     {
    14.         printf("handler with ctrl+c\n");
    15.     }
    16. }
    17. int main()
    18. {
    19.     // signal(SIGALRM,SIG_IGN);/sigalrm信号被忽略        则pause不会接收到信号，一直挂起
    20.  
    21.     // signal(SIGALRM,SIG_DFL);//sigalrm信号变为默认     则五秒后，printf输出；
    22.  
    23.     signal(SIGALRM, handler); // sigalrm信号转向 ”处理函数“————handler；
    24.     signal(SIGINT, handler);
    25.  
    26.     alarm(5);
    27.     pause(); // 当处理了一个信号处理函数，会唤醒pause
    28.  
    29.     printf("main is over\n");
    30.     return 0;
    31. }
    sigaction


    异步IO的实现

    fcntl(0, __F_SETOWN, getpid()); // 将sigio信号设置成由当前的进程接收

    signal(SIGIO, handler); // 设置信号处理函数

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. void handler(int sig) // 定义的信号处理函数
    12. {
    13.     char buffer[1024];
    14.     memset(buffer, 0, sizeof(buffer));
    15.     int ret = read(0, buffer, sizeof(buffer) - 1);
    16.     buffer[ret] = '\0';
    17.     printf("%s\n", buffer);
    18. }
    19.  
    20. int main(int argc, char **argv)
    21. {
    22.     int fd;
    23.     fd = open("/dev/input/mouse0", O_RDWR); // 打开一个文件描述符
    24.     if (fd == -1)
    25.     {
    26.         perror("fd open error\n");
    27.         exit(-1);
    28.     }
    29.     int flags = fcntl(0, F_GETFL);
    30.     flags = flags | O_ASYNC; // 获取fd的flags，并加上0_ASYNC(异步读取)
    31.     fcntl(0, F_SETFL, flags);
    32.  
    33.     fcntl(0, __F_SETOWN, getpid()); // 将sigio信号设置成由当前的进程接收
    34.  
    35.     signal(SIGIO, handler); // 设置信号线处理函数
    36.  
    37.     while (1) // 主函数的操作不受影响
    38.     {
    39.         int cor = 0;
    40.         read(fd, &cor, sizeof(int));
    41.         printf("handler is going: cor =%d\n", cor);
    42.     }
    43.     return 0;
    44. }

    优化进程等待

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. void handler(int sig)
    13. {
    14.     wait(NULL);
    15.     printf(("handler & wait\n"));
    16. }
    17. int main()
    18. {
    19.     signal(SIGCHLD, handler);
    20.     pid_t pid = fork();
    21.     if (pid > 0)
    22.     {
    23.         while (1)
    24.         {
    25.             printf("father is going\n");
    26.             sleep(1);
    27.         }
    28.     }
    29.     if (pid == 0)
    30.     {
    31.         printf("child is going\n");
    32.     }
    33.     return 0;
    34. }

    信号屏蔽字

    作用：屏蔽信号

    sigset_t数据类型

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. int main(int argc, char **argv)
    7. {
    8.     sigset_t set;                         // 定义一个信号字
    9.     sigemptyset(&set);                    // 清空：全置为0
    10.     sigaddset(&set, SIGINT);              // 将sigint信号加入该信号集——也就是将对应位置为1
    11.     sigprocmask(SIG_SETMASK, &set, NULL); // 设置信号罩
    12.  
    13.     pid_t pid = fork();
    14.     if (pid > 0)
    15.     {
    16.         while (1)
    17.         {
    18.             printf("father \n");
    19.             sleep(1);
    20.         }
    21.     }
    22.     if (pid == 0)
    23.     {
    24.         while (1)
    25.         {
    26.             printf("child \n");
    27.             sleep(1);
    28.         }
    29.     }
    30.     return 0;
    31. }

    未决（处理）信号集

    也是六十四位的int，记录了未处理的信号

    pause() 函数会一直等待直到收到一个信号。当进程接收到一个信号时，如果该信号没有被忽略并且没有注册对应的信号处理函数，pause() 函数会被信号中断并返回 -1，同时将 errno 设置为 EINTR。 

    管道

    无格式，读取后数据会删除

    无名管道

    内核会开辟一个“管道”，通信的进程通过共享这个管道从而实现通信

    int pipe（int pipefd【2】）；

    特点：

    1.只允许具有血管关系的进程间通信，如父子进程间的通信

    2.管道只允许单向通信

    3.读管道时，没有数据就会堵塞；写数据，写满缓冲区会休眠

    4.数据被读出后，数据就会被管道删除

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. int main(int agrc, char **argv)
    10. {
    11.     int fd[2];
    12.     pipe(fd);
    13.     pid_t pid = fork();
    14.     if (pid > 0)
    15.     {
    16.         close(fd[0]);
    17.         char buffer[1024];
    18.         while (1)
    19.         {
    20.             memset(buffer, 0, sizeof(buffer));
    21.             scanf("%s", buffer);
    22.             write(fd[1], buffer, sizeof(buffer));
    23.         }
    24.     }
    25.     else if (pid == 0)
    26.     {
    27.         int flags =fcntl(fd[0],F_GETFL);
    28.         flags=flags|O_NONBLOCK;
    29.         fcntl(fd[0],F_SETFL,flags);
    30.         
    31.         close(fd[1]);
    32.         char buffer[1024];
    33.         while (1)
    34.         {
    35.             memset(buffer, 0, sizeof(buffer));
    36.             read(fd[0], buffer, sizeof(buffer));
    37.             printf("buffer is %s\n", buffer);
    38.             sleep(1);
    39.         }
    40.     }
    41.     return 0;
    42. }

    注意事项

    SIGPIPE信号：

    1.写管道时，如果管道的读端被close了话，向管道"写"数据的进程会被内核发送一个SIGPIPE信号，发这个信号的目的就是想通知你，管道所有的"读"都被关闭了。

    2.由于这个信号的默认动作是终止，所以收到这个信号的进程会被终止，如果你不想被终止的
    话，你可以忽略、捕获、或者屏蔽这个信号。
    3.只有当管道所有的读端都被关闭时，才会产生这个信号，只有还有一个读端开着，就不会产生
     

    signal （SIGPIPE, SIG_IGN）来忽略sigpipe这个信号

    无名管道结合异步IO 

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. int fd[2];
    11. void handle(int sig)
    12. {
    13.     if (sig == SIGIO)
    14.     {
    15.         char buffer[1024];
    16.         memset(buffer, 0, sizeof(buffer));
    17.         read(fd[0], buffer, sizeof(buffer) - 1);
    18.         printf("%s\n", buffer);
    19.     }
    20. }
    21. int main(int agrc, char **argv)
    22. {
    23.  
    24.     pipe(fd);
    25.     pid_t pid = fork();
    26.     if (pid > 0) // 父进程：写
    27.     {
    28.         close(fd[0]);
    29.         char buffer[1024];
    30.         while (1)
    31.         {
    32.             memset(buffer, 0, sizeof(buffer));
    33.             scanf("%s", buffer);
    34.             write(fd[1], buffer, strlen(buffer));
    35.         }
    36.     }
    37.     else if (pid == 0) // 子进程：读
    38.     {
    39.         // close(fd[0]);
    40.         close(fd[1]);
    41.  
    42.         int flags = fcntl(fd[0], F_GETFL);
    43.         flags = flags | O_ASYNC;
    44.         fcntl(fd[0], F_SETFL, flags);
    45.  
    46.         fcntl(fd[0], __F_SETOWN, getpid());
    47.         signal(SIGIO, handle);
    48.         
    49.         pause();
    50.     }
    51.     return 0;
    52. }

    有名管道

    管道应用的一个重大限制是它没有名字，只适合具有亲缘性质的进程之间通信。命名管道克服了这种限制，FIFO不同于管道之处在于它提供一个路径名与之关联，以FIFO的文件形式存在于文件系统中。这样，即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信（能够访问该路径的进程以及FIFO的创建进程之间)，因此，通过FIFO不相关的进程也能交换数据。 

    例子：

    1. FILE1:
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. #define FILE_PATH "./pipe"
    13.  
    14. void rm_pipe(int sig)
    15. {
    16.     if(sig==SIGINT)
    17.     {
    18.         remove(FILE_PATH);
    19.     }
    20. }
    21.  
    22. int main()
    23. {
    24.     if(mkfifo(FILE_PATH,0777)<0)
    25.     {
    26.         perror("mkfifo error");
    27.         exit(-1);
    28.     }
    29.     int fd=open(FILE_PATH,O_WRONLY);
    30.     if(fd==-1)
    31.     {
    32.         perror("fd open error");
    33.         exit(-1);
    34.     }
    35.     signal(SIGINT,rm_pipe);
    36.     while(1)
    37.     {
    38.         char buffer[1024];
    39.         memset(buffer,0,sizeof(buffer));
    40.         scanf("%s",buffer);
    41.         write(fd,buffer,strlen(buffer));
    42.     }
    43.     return 0;
    44. }
    45.  
    46. FILE2:
    47.  
    48. #include 
    49. #include 
    50. #include 
    51. #include 
    52. #include 
    53. #include 
    54. #include 
    55. #include 
    56.  
    57. #define FILE_PATH "./pipe"
    58.  
    59. int main()
    60. {
    61.     int fd=open(FILE_PATH,O_RDONLY);
    62.     if(fd==-1)
    63.     {
    64.         perror("fd open error");
    65.         exit(-1);
    66.     }
    67.     while(1)
    68.     {
    69.         char buffer[1024];
    70.         memset(buffer,0,sizeof(buffer));
    71.         int ret=read(fd,buffer,sizeof(buffer)-1);
    72.         buffer[ret]='\0';
    73.         printf("%s\n",buffer);
    74.     }
    75.     return 0;
    76. }

    注意事项：

    “"有名管道"这种特殊文件，只能使用mkfifo函数来创建
    为了保证有名管道一定被创建，最好是两个进程都包含创建管道的代码，谁先运行就谁先创建，后运行的发现管道经创建好了，那就直接open打开使用。
    不能以O_RDWR模式打开命名管道FIFO文件，否则其行为是未定义的，管道是单向的，不能同时读写
     

    System V IPC

    特点：

    与管道不同，他完全使用了不同的实现机制，与文件没有任何关系，也就是说内核不再以文件形式

    System V IPC不在以文件形式存在，所以没有文件描述符这个东西，但有类似的标识符

    任何进程间通信时，都可以使用System V IPC来通信

    优点：减少进程间通信的开销（文件的开销大于链表、内存、整形）；Linux和Unix都通用

    消息队列

    消息队列的本质就是由内核创建的用于存放消息的链表，由于是存放消息的，所以我们就把这个链表称为消息队列


    分类

    System V的消息队列
    Posix消息队列团


    消息的组成（结构体）

    1.消息编号：识别消息；

    2.消息正文：真正的信息内容

    消息队列API

    创建

    key值：

    1.指定为IPC_PRIVATE宏，指定这个宏后，每次调用msgget时都会创建一个新的消息
    队列。如果你每次使用的必须是新消息队列的话，就可以指定这个，不过这个用的很少。因为一般来说，只要有一个消息队列可以用来通信就可以了﹐并不需要每次都创建一个全新的消息队列。
    2.自己指定一个整数型，但容易重复指定。本来我想创建一个新的消息队列，结果我所指定的这个整形数﹐之前就已经被用于创建某个消息队列了，当我的指定重复时msgget就不会创建新消息队列，而是使用的是别人之前就创建好的消息队列。所以我们也不会使用这种方式来指定key值
    3.key_t ftok(const char *pathname, int proj_id);
    ftok通过指定路径名和一个整形数，就可以计算并返回一个唯一对应的key值，只要路径名和整形数不变，所对应的key值就唯一不变的。
    不过由于ftok只会使用整形数《 proj_id》的低8位，因此我们往往会指定为一个ASCII码值,因为ASCII码值刚好是8位的整形数。

    msgflag
    指定创建时的原始权限,比如0664
    创建一个新的消息队列时，除了原始权限，还需要指定IPC_CREAT选项。
    msgid = msgget(key, 0664 | IPC_CREAT);
     

    查看消息队列命令：

    ipcs -a是默认的输出信息:打印出当前系统中所有的进程间通信方式的信息

    ipcs -m打印出使用共享内存进行进程间通信的信息

    ipcs -q打印出使用消息队列进行进程间通信的信息

    ipcs -s打印出使用信号量进行进程间通信的信息
     

    获取属性及删除

    进程结束后，system v ipc不会自动删除，进程结束后，使用ipc依然能够查看到

    1.重启OS

    2.使用ipcrm命令删除：

    ipcrm -Q msgkey移除用msqkey创建的消息队列
    ipcrm -q msqid移除用msqid标识的消息队列


    3.int msgctl(int msqid, int cmd, struct msqid_ds *buf);//也可以获取消息队列的属性

    cmd：

    IPC_STAT：将msqid消息队列的属性信息，读到第三个参数所指定的缓存。

    IPC_SET：IPC_SET:使用第三个参数中的新设置去依改消息队列的属性
            定一个struct msqid_ds buf
            将新的属性信息设置到buf中
            cmd指定为IPC_SET后，msgctl函数就会使用buf中的新属性去修改消息队列原有的属性

    IPC_RMID：删除消息队列，第三个参数置为空

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #define FILE "./msg_file"
    7. int main()
    8. {
    9.     key_t key;
    10.     key = ftok(FILE, 'F'); // 定义key值
    11.  
    12.     int msgid = msgget(key, 0777 | IPC_CREAT); // 创建消息队列
    13.     if (msgid < 0)
    14.     {
    15.         perror("msgget error");
    16.     }
    17.     printf("%x\n", key);
    18.     printf("%d\n", msgid);
    19.  
    20.     // msgctl(msgid,IPC_RMID,NULL); 删除队列
    21.     return 0;
    22. }
    发送

    接收

     删除

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. #define FILE_PATH "./path"
    13. int msgpid;
    14. void handler(int sig)
    15. {
    16.     if (sig == SIGINT)
    17.     {
    18.         msgctl(msgpid, IPC_RMID, NULL);
    19.     }
    20. }
    21. struct msgbuf
    22. {
    23.     long mstype;
    24.     char mstext[1024];
    25. };
    26. int main(int argc, char **argv)
    27. {
    28.     signal(SIGINT, handler); // 后续循环只能用ctrl+c来退出，只能通过信号处理函数来删除信号队列
    29.  
    30.     key_t key = ftok(FILE_PATH, 'K');
    31.  
    32.     msgpid = msgget(key, 0777 | IPC_CREAT);
    33.     if (msgpid < 0)
    34.     {
    35.         perror("msgget error");
    36.     }
    37.     pid_t pid = fork();
    38.     if (pid < 0)
    39.     {
    40.         perror("fork error");
    41.     }
    42.     else if (pid == 0) // 发消息到队列
    43.     {
    44.         while (1)
    45.         {
    46.             struct msgbuf m1;
    47.             memset(&m1, 0, sizeof(struct msgbuf));
    48.  
    49.             printf("input type:");
    50.             scanf("%ld", &m1.mstype);
    51.             printf("input text:");
    52.             scanf("%s", m1.mstext);
    53.  
    54.             if (msgsnd(msgpid, &m1, sizeof(m1.mstext), IPC_NOWAIT) < 0)
    55.             {
    56.                 perror("msgsnd error");
    57.                 _exit(-1);
    58.             }
    59.         }
    60.     }
    61.     else // 从队列读消息
    62.     {
    63.         while (1)
    64.         {
    65.             struct msgbuf m2;
    66.             memset(&m2, 0, sizeof(struct msgbuf));
    67.             if (msgrcv(msgpid, &m2, sizeof(m2.mstext), 3, MSG_NOERROR) < 0)
    68.             {
    69.                 perror("msgrcv error");
    70.                 exit(-1);
    71.             }
    72.             else
    73.             {
    74.                 printf("msg rcv:%s\n", m2.mstext);
    75.             }
    76.             sleep(1);
    77.         }
    78.     }
    79.  
    80.     return 0;
    81. }

    消息队列的使用步骤

     
    创建        收发        删除


    代码实例


    消息队列的特点

    传送有格式的消息流

    多进程网状交叉通信，消息队列是上上之选

    能实现大规模（进程规模多，不是说数据量大）数据的通信

    通过共同参数的ftok函数，生成的信号队列，可以实现两个无血缘关系进程的读写：

    1. msg_write.c:
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12.  
    13. #define FILE_PATH "./path"
    14. int msgpid;
    15. void handler(int sig)
    16. {
    17.     if (sig == SIGINT)
    18.     {
    19.         msgctl(msgpid, IPC_RMID, NULL);
    20.     }
    21. }
    22. struct msgbuf
    23. {
    24.     long mstype;
    25.     char mstext[1024];
    26. };
    27. int main(int argc, char **argv)
    28. {
    29.     signal(SIGINT, handler); // 后续循环只能用ctrl+c来退出，只能通过信号处理函数来删除信号队列
    30.  
    31.     key_t key = ftok(FILE_PATH, 'K');
    32.  
    33.     msgpid = msgget(key, 0777 | IPC_CREAT);
    34.     if (msgpid < 0)
    35.     {
    36.         perror("msgget error");
    37.     }
    38.         while (1)
    39.         {
    40.             struct msgbuf m1;
    41.             memset(&m1, 0, sizeof(struct msgbuf));
    42.  
    43.             printf("input type:");
    44.             scanf("%ld", &m1.mstype);
    45.             printf("input text:");
    46.             scanf("%s", m1.mstext);
    47.  
    48.             if (msgsnd(msgpid, &m1, sizeof(m1.mstext), IPC_NOWAIT) < 0)
    49.             {
    50.                 perror("msgsnd error");
    51.                 _exit(-1);
    52.             }
    53.         }
    54.     return 0;
    55. }
    56.  
    57.  
    58. msg_read.c :
    59. #include 
    60. #include 
    61. #include 
    62. #include 
    63. #include 
    64. #include 
    65. #include 
    66. #include 
    67. #include 
    68. #include 
    69.  
    70. #define FILE_PATH "./path"
    71. int msgpid;
    72. void handler(int sig)
    73. {
    74.     if (sig == SIGINT)
    75.     {
    76.         msgctl(msgpid, IPC_RMID, NULL);
    77.     }
    78. }
    79. struct msgbuf
    80. {
    81.     long mstype;
    82.     char mstext[1024];
    83. };
    84. int main(int argc, char **argv)
    85. {
    86.     signal(SIGINT, handler); // 后续循环只能用ctrl+c来退出，只能通过信号处理函数来删除信号队列
    87.  
    88.     key_t key = ftok(FILE_PATH, 'K');
    89.  
    90.     msgpid = msgget(key, 0777 | IPC_CREAT);
    91.     if (msgpid < 0)
    92.     {
    93.         perror("msgget error");
    94.     }
    95.     while (1)
    96.     {
    97.         struct msgbuf m2;
    98.         memset(&m2, 0, sizeof(struct msgbuf));
    99.         if (msgrcv(msgpid, &m2, sizeof(m2.mstext), 3, 0) < 0)  //阻塞的读
    100.         {
    101.             perror("msgrcv error");
    102.             exit(-1);
    103.         }
    104.         else
    105.         {
    106.             printf("msg rcv:%s\n", m2.mstext);
    107.         }
    108.         sleep(1);
    109.     }
    110.     return 0;
    111. }

    共享内存

    让同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新

    API：

    创建：

    删除：

    1.重启OS

    2.使用ipcrm命令删除：

    ipcrm -M shmkey移除用shmkey创建的共享内存段
    ipcrm -m shmid移除用shmid标识的共享内存段

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

    映射：

    1. char *shm_c = shmat(shmid1, NULL, 0); // shmat结果是void类型的指针（强制类型转换）
    2.     // null代表系统分配内存地址；
    3.     // 0代表可读可写；shm_rdonly代表只读

    取消映射：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #define SIZE_T 4096
    10. #define FILE_PATh ".demo1"
    11.  
    12. int shmid1;
    13.  
    14. void handler(int sig)
    15. {
    16.     shmctl(shmid1, IPC_RMID, NULL);
    17.     printf("delete done\n");
    18.     exit(1);
    19. }
    20.  
    21. int main(int argc, char **argv)
    22. {
    23.     key_t key1 = ftok(FILE_PATh, 'F');
    24.     shmid1 = shmget(key1, SIZE_T, 0777 | IPC_CREAT);
    25.     if (shmid1 == -1)
    26.     {
    27.         perror("shmget error");
    28.         exit(-1);
    29.     }
    30.     signal(SIGINT, handler);
    31.     char *shm_c = shmat(shmid1, NULL, 0); // shmat结果是void类型的指针（强制类型转换）
    32.     // null代表系统分配内存地址；
    33.     // 0代表可读可写；shm_rdonly代表只读
    34.  
    35.     pid_t pid = fork();
    36.     if (pid < 0)
    37.     {
    38.         perror("fork error");
    39.         exit(-1);
    40.     }
    41.     else if (pid > 0) // 父进程 用来向内存写
    42.     {
    43.         while (1)
    44.         {
    45.             char buffer[1024];
    46.             memset(buffer, 0, sizeof(buffer));
    47.             scanf("%s", buffer);
    48.             strcpy(shm_c, buffer);
    49.         }
    50.     }
    51.     else // 子进程  用来从内存读
    52.     {
    53.         while (1)
    54.         {
    55.             char buffer[1024];
    56.             memset(buffer, 0, sizeof(buffer));
    57.             memcpy(buffer, shm_c, sizeof(buffer));
    58.             memset(shm_c, 0, sizeof(buffer));
    59.             printf("receive buffer = %s\n", buffer);
    60.             sleep(1);
    61.         }
    62.     }
    63.     return 0;
    64. }

    改进为阻塞读取（以节省CPU资源）：

    1.信号：

    【pause() 函数会一直等待直到收到一个信号。当进程接收到一个信号时，如果该信号没有被忽略并且没有注册对应的信号处理函数，pause() 函数会被信号中断并返回 -1，同时将 errno 设置为 EINTR】

    2.信号量

    特点

    开销最小，减少进入内核次数；

    直接使用地址来读写，效率更高，适用于大数据量的通信

    作业：实现任意进程间的阻塞读取

    1. 读数据：
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13.  
    14. #define FILE_PATH "./pipe_file"
    15. #define SIZE_T 4096
    16.  
    17. void handler(int sig)
    18. {
    19.     if (sig == SIGINT)
    20.     {
    21.         remove(FILE_PATH);
    22.         exit(-1);
    23.     }
    24.     if (sig == SIGUSR1)//空处理，可以唤醒pause
    25.     {
    26.     }
    27. }
    28. int main(int argc, char **argv) // 读
    29. {
    30.     signal(SIGINT, handler);
    31.     signal(SIGUSR1, handler);
    32.     if (mkfifo(FILE_PATH, 0777) < 0) // 创建有名管道
    33.     {
    34.         perror("mkfifo error");
    35.         exit(-1);
    36.     }
    37.     int fd = open(FILE_PATH, O_WRONLY); /// 只写打开有名管道文件
    38.     if (fd < 0)
    39.     {
    40.         perror("open error");
    41.         exit(-1);
    42.     }
    43.     pid_t pid1 = getpid(); // 获取当前进程pid号，并通过有名管道传给 写 进程
    44.     printf("%d\n", pid1);
    45.     if (write(fd, &pid1, sizeof(pid_t)) < 0)
    46.     {
    47.         perror("write pid1 error");
    48.         exit(-1);
    49.     }
    50.  
    51.     key_t key1 = ftok(FILE_PATH, 'F'); // 配置共享内存
    52.     int shmid1 = shmget(key1, SIZE_T, 0777 | IPC_CREAT);
    53.     if (shmid1 < 0)
    54.     {
    55.         perror("shmid1 error");
    56.         exit(-1);
    57.     }
    58.     char *shm = (char *)shmat(shmid1, NULL, 0); // 共享内存
    59.     if (shm == NULL)
    60.     {
    61.         perror("shm error");
    62.         exit(-1);
    63.     }
    64.     while (1) // 取出共享内存内的数据
    65.     {
    66.         printf("please wait output\n");
    67.         pause();
    68.         char buffer[1024];
    69.         memset(buffer, 0, sizeof(buffer));
    70.         strcpy(buffer, shm);
    71.         printf("receive buffer :%s\n", buffer);
    72.         memset(shm, 0, SIZE_T);
    73.     }
    74.     return 0;
    75. }
    76.  
    77. 写数据：
    78. #include 
    79. #include 
    80. #include 
    81. #include 
    82. #include 
    83. #include 
    84. #include 
    85. #include 
    86. #include 
    87. #include 
    88. #include 
    89.  
    90. #define FILE_PATH "./pipe_file"
    91. #define SIZE_T 4096
    92.  
    93. int main(int argc, char **argv) // 写
    94. {
    95.     int fd = open(FILE_PATH, O_RDONLY); // 只读打开有名管道
    96.     if (fd < 0)
    97.     {
    98.         perror("open error");
    99.         exit(-1);
    100.     }
    101.     pid_t pid1;
    102.     read(fd, &pid1, sizeof(pid_t)); // 把 读 进程pid号通过管道读出来
    103.     printf("%d\n",pid1);
    104.  
    105.  
    106.  
    107.     key_t key1 = ftok(FILE_PATH, 'F'); // 配置共享内存
    108.     int shmid1 = shmget(key1, SIZE_T, 0777 | IPC_CREAT);
    109.     if (shmid1 < 0)
    110.     {
    111.         perror("shmid1 error");
    112.         exit(-1);
    113.     }
    114.     char *shm = (char*)shmat(shmid1, NULL, 0); // 共享内存
    115.     if (shm == NULL)
    116.     {
    117.         perror("shm error");
    118.         exit(-1);
    119.     }
    120.     while (1) // 写数据，写完就传个信号给 读 进程
    121.     {
    122.         char buffer[1024];
    123.         
    124.         printf("please input\n");
    125.         scanf("%s", buffer);
    126.         strcpy(shm, buffer);
    127.         kill(pid1,SIGUSR1);
    128.     }
    129.     return 0;
    130. }

    信号量（信号锁、信号灯）

    当多个进程/线程进行共享访问的时候，用于资源保护，以防止资源出现干扰的情况

    进程同步：进程按照一定的顺序执行（不是指先后顺序，而是指互斥）

    进程竞态：

    互斥：对于互斥操作来说，多进程共享操作时，多个进程间不关心谁先操作、谁后操作的先后顺序问题，它们只关心，自己操作时候，别人不能操作

    同步：所谓同步就是，多个共享操作时，进程必须要有统
    操作的步调，按照一定的顺序来操作

    解决方法：加锁

    信号量（信号锁）：信号量其实是一个OS创建的，供相关进程共享的int变量，只不过我们在调用相关API创建信号量时，我们创建的都是一个信号量集合，所谓集合就是可能会包含好多个信号量。
    用于互斥时，集合中只包含一个信号量。
    用于同步时，集合中会包含多个信号量，至于多少个，需要看情况

    API：

    1.配置信号队列：int semget (key_t key,int nsems,int semflg)

    参数：
    key：用ftok获取key值
    nsems：指定集合中信号量的个数        【用于互斥时，数量都指定为1，因为只需要一个信号量】
    semfig：权限：―般都设置为0664 | IPC_CREAT        【设置同消息队列和共享内存】        

    2.控制信号队列：int semctl(int semid,int semnum,int cmd,...)

    参数：

    semnum：集合中某个信号量的编号（集合中某个信号量的编号：信号量的编号为非负整数，而且是自动从0开始）

    cmd：IPC_STAT;        IPC_SET;         IPC_RMID

    可变参数：......

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #define FILE_PATH "./sem_demo"
    12.  
    13. int semid;
    14. void delete_sem(int, int);
    15. void handler(int sig)
    16. {
    17.     delete_sem(semid, 0);
    18. }
    19.  
    20. void creat_sem(int nsems) // 创建
    21. {
    22.     key_t key = ftok(FILE_PATH, 'f');
    23.     int semid = semget(key, nsems, 0777 | IPC_CREAT);
    24.     if (semid < 0)
    25.     {
    26.         perror("semget error");
    27.         exit(-1);
    28.     }
    29. }
    30. void init_sem(int semid, int semnum, int val) // 初始化制定信号量的值
    31. {
    32.     semctl(semid, semnum, SETVAL, val);
    33. }
    34. void delete_sem(int semid, int semnum) // 删除制定信号量的值
    35. {
    36.     if (semctl(semid, semnum, IPC_RMID) < 0)
    37.     {
    38.         perror("semctl delete error");
    39.     }
    40. }
    41. int main(int argc, char **argv)
    42. {
    43.  
    44.     key_t key = ftok(FILE_PATH, 'F');
    45.     semid = semget(key, 3, 0777 | IPC_CREAT);
    46.     if (semid < 0)
    47.     {
    48.         perror("semget error");
    49.         exit(-1);
    50.     }
    51.     printf("%d\n", semid);
    52.     pid_t pid = fork();
    53.     if (pid > 0)
    54.     {
    55.         
    56.         while (1)
    57.         {
    58.             sleep(1);
    59.         }
    60.     }
    61.     if (pid == 0)
    62.     {
    63.         signal(SIGINT, handler);//只能在子进程中注册，在main函数内注册的话，当contrl+c时候，，父子进程都要调用一次handler，也就是删除的函数，则会报错
    64.         while (1)
    65.         {
    66.             sleep(1);
    67.         }
    68.     }
    69.     
    70.     // printf("%x\n", key);
    71.     //  semctl(semid, 0, IPC_RMID);
    72.  
    73.     return 0;
    74. }
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. #define FILE_PATH "./sem_demo"
    13.  
    14. int semid;
    15. pid_t pid;
    16. void delete_sem(int);
    17.  
    18. void handler(int sig)
    19. {
    20.     printf("handler is used\n");
    21.     delete_sem(0);
    22.     semctl(semid, 0, IPC_RMID);
    23.     exit(-1);
    24. }
    25.  
    26. void lock(int semid1, int semnum1) // 封装 上锁 函数
    27. {
    28.     struct sembuf sembuffer1[1];
    29.     sembuffer1[0].sem_num = semnum1;
    30.     sembuffer1[0].sem_op = -1;
    31.     sembuffer1[0].sem_flg = SEM_UNDO;
    32.     semop(semid1, sembuffer1, 1);
    33. }
    34.  
    35. void unlock(int semid1, int semnum1) // 封装 解锁 函数
    36. {
    37.     struct sembuf sembuffer1[1];
    38.     sembuffer1[0].sem_num = semnum1;
    39.     sembuffer1[0].sem_op = 1;
    40.     sembuffer1[0].sem_flg = SEM_UNDO;
    41.     semop(semid1, sembuffer1, 1);
    42. }
    43.  
    44. void creat_sem(int nsems) // 创建
    45. {
    46.     key_t key = ftok(FILE_PATH, 'f');
    47.     semid = semget(key, nsems, 0777 | IPC_CREAT);
    48.     if (semid < 0)
    49.     {
    50.         perror("semget error");
    51.         exit(-1);
    52.     }
    53. }
    54. void init_sem(int semid, int semnum, int val) // 初始化指定信号量的值
    55. {
    56.     semctl(semid, semnum, SETVAL, val);
    57. }
    58. void delete_sem(int semnum) // 删除制定信号量的值
    59. {
    60.     if (semctl(semid, semnum, IPC_RMID) < 0)
    61.     {
    62.         perror("semctl delete error");
    63.     }
    64.     printf("delete done\n");
    65. }
    66. int main(int argc, char **argv)
    67. {
    68.     int fd = open("a.txt", O_WRONLY | O_APPEND | O_CREAT, 0655);
    69.     if (fd == -1)
    70.     {
    71.         perror("fd error");
    72.         exit(-1);
    73.     }
    74.  
    75.     creat_sem(1);
    76.     init_sem(semid, 0, 1);
    77.     printf("%d\n", semid);
    78.  
    79.     pid = fork();
    80.     if (pid > 0)
    81.     {
    82.         while (1)
    83.         {
    84.             lock(semid, 0);
    85.             write(fd, "helloworld", 10);
    86.             write(fd, "helloworld", 10);
    87.             write(fd, "\n", 1);
    88.             unlock(semid, 0);
    89.             sleep(1);
    90.         }
    91.     }
    92.     if (pid == 0)
    93.     {
    94.         signal(SIGINT, handler); // 只能在子进程中注册，在main函数内注册的话，当contrl+c时候，，父子进程都要调用一次handler，也就是删除的函数，则会报错
    95.         while (1)
    96.         {
    97.             lock(semid, 0);
    98.             write(fd, "hhhhhwwwww", 10);
    99.             write(fd, "hhhhhwwwww", 10);
    100.             write(fd, "\n", 1);
    101.             unlock(semid, 0);
    102.             sleep(1);
    103.         }
    104.     }
    105.     return 0;
    106. }

    作业：

    答： 

    1. sem.h:
    2. #ifndef _MYSEM_H_
    3. #define _MYSEM_H_
    4.  
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15.  
    16. #define FILE_PATH "./sem_demo"
    17.  
    18. void creat_sem(int *semid, int nsems);         // 创建
    19. void init_sem(int semid, int semnum, int val); // 初始化指定信号量的值
    20. void lock(int semid1, int semnum1);            // 封装 上锁 函数
    21. void unlock(int semid1, int semnum1);          // 封装 解锁 函数
    22. void delete_sem(int semid, int semnum);        // 删除制定信号量的值
    23. #endif
    24.  
    25. sem.c:
    26.  
    27.  
    28. #include "sem.h"
    29.  
    30. void delete_sem(int semid, int semnum) // 删除制定信号量的值
    31. {
    32.     if (semctl(semid, semnum, IPC_RMID) < 0)
    33.     {
    34.         perror("semctl delete error");
    35.     }
    36.     printf("delete done\n");
    37. }
    38.  
    39. void lock(int semid1, int semnum1) // 封装 上锁 函数
    40. {
    41.     struct sembuf sembuffer1[1];
    42.     sembuffer1[0].sem_num = semnum1;
    43.     sembuffer1[0].sem_op = -1;
    44.     sembuffer1[0].sem_flg = SEM_UNDO;
    45.     semop(semid1, sembuffer1, 1);
    46. }
    47.  
    48. void unlock(int semid1, int semnum1) // 封装 解锁 函数
    49. {
    50.     struct sembuf sembuffer1[1];
    51.     sembuffer1[0].sem_num = semnum1;
    52.     sembuffer1[0].sem_op = 1; 
    53.     sembuffer1[0].sem_flg = SEM_UNDO;
    54.     semop(semid1, sembuffer1, 1);
    55. }
    56.  
    57. void creat_sem(int *semid,int nsems) // 创建
    58. {
    59.     key_t key = ftok(FILE_PATH, 'f');
    60.     *semid = semget(key, nsems, 0777 | IPC_CREAT);
    61.     if (semid < 0)
    62.     {
    63.         perror("semget error");
    64.         exit(-1);
    65.     }
    66. }
    67.  
    68. void init_sem(int semid, int semnum, int val) // 初始化指定信号量的值
    69. {
    70.     semctl(semid, semnum, SETVAL, val);
    71. }
    72.  
    73. sem_abcd.c:
    74.  
    75. #include "sem.h"
    76. int semid;
    77. int main(int argc, char **argv)
    78. {
    79.     creat_sem(&semid, 4);
    80.     init_sem(semid, 0, 1);
    81.     for (int i = 1; i < 4; ++i)
    82.     {
    83.         init_sem(semid, i, 0);
    84.     }
    85.     pid_t pid1 = fork();
    86.     if (pid1 > 0)
    87.     {
    88.         pid_t pid2 = fork();
    89.         if (pid2 > 0)
    90.         {
    91.             while (1)
    92.             {
    93.                 lock(semid, 0);
    94.                 printf("A\n");
    95.                 sleep(1);
    96.                 unlock(semid, 1);
    97.             }
    98.         }
    99.         if (pid2 == 0)
    100.         {
    101.             while (1)
    102.             {
    103.                 lock(semid, 1);
    104.                 printf("B\n");
    105.                 sleep(1);
    106.                 unlock(semid, 2);
    107.             }
    108.         }
    109.     }
    110.     else if (pid1 == 0)
    111.     {
    112.         pid_t pid3 = fork();
    113.         if (pid3 > 0)
    114.         {
    115.             while (1)
    116.             {
    117.                 lock(semid, 2);
    118.                 printf("C\n");
    119.                 sleep(1);
    120.                 unlock(semid, 3);
    121.             }
    122.         }
    123.         if (pid3 == 0)
    124.         {
    125.             while (1)
    126.             {
    127.                 lock(semid, 3);
    128.                 printf("D\n");
    129.                 sleep(1);
    130.                 unlock(semid, 0);
    131.             }
    132.         }
    133.     }
    134.     return 0;
    135. }

    google  笔试题：

    Google多线程面试题: 4个线程向4个文件里写入数据, 每个线程只能写一个值

  • 相关阅读:
    晨控CK-GW06系列网关与汇川可编程控制器MOSBUSTCP通讯手册
    LINUX安装openssl
    Selenium环境+元素定位大法
    Java版本电子招标采购系统源码:营造全面规范安全的电子招投标环境，促进招投标市场健康可持续发展
    Java核心编程(15)
    介绍一个中后台管理系统
    c语言---指针进阶（1）
    达人评测i7 12700kf和i9 12900kf选哪个好
    python 学习：各种符号的意思\n \t等
    使用dockerfile自定义Tomcat镜像
  • 原文地址：https://blog.csdn.net/qq_58170320/article/details/132483247