第11章 进程间通信（1）_管道

最新推荐文章于 2023-02-15 13:38:36 发布
最新推荐文章于 2023-02-15 13:38:36 发布
阅读量181 收藏
点赞数
分类专栏： Linux应用程序

1. 进程间通信概述

（1）概述

　　①数据传输：一个进程需要将它的数据发送给另一个进程，发送的数据量在一个字节到几兆字节之间。

　　②共享数据：多个进程想要操作共享数据，一个进程对共享数据的修改，别的进程应该立刻看到。

　　③通知事件：一个进程需要向另一个(组)进程发送消息，通知它们发生了某种事件(如进程终止时要通知父进程)。

　　④资源共享：多个进程之间共享同样的资源。为了做到这一点，需要内核提供锁和同步机制。

　　⑤进程控制：有些进程希望完全控制另一个进程的执行(如Degub进程)，此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

（2）现代的进程间通信方式

　　①管道(pipe)和命名管理(FIFO)    ②信号(signal)    ③消息队列    ④共享内存    ⑤信号量    ⑥套接字(socket)

2. 管道通信

2.1 概述

（1）管道是针对本地计算机的两个进程之间的通信而设计的通信方法，管道建立后，实际获得的是两个文件描述符：一个用于读取，另一个用于写入。

（2）最常见的IPC机制，通过pipe系统调用

（3）管道是单工的，数据只能向一个方向流动，需要双向通信时，需要建立起两个管道。

（4）数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据（即读取的顺序应与写入的顺序一致！）

2.2 管道的分类和读写

（1）管道的分类

　　①匿名管道：

　　　　A.在关系进程中进程（父进程和子进程，兄弟进程之间）

　　　　B.由pipe系统调用，管道由父进程建立

　　　　C.管道位于内核空间，其实是一块缓存

　　②命名管道(FIFO)：

　　　　A.两个没有任何关系的进程之间通信可通过命名管道进行数据传输，本质上是内核中一块缓存，另在文件系统中以一个特殊的设计文件（管道文件）存在。

　　　　B.通过系统调用mkfifo创建。

（2）管道的创建： 

头文件

#include <unistd.h>

函数

int pipe(int fd[2]);

功能

等待一个或者多个指定信号发生

返回值

成功返回0，否则返回-1

备注

①fd[0]：为pipe的读端，用于读取管道。

②fd[1]：为pipe的写端，用于写入管道。

（2）管道的读写

　　①管道主要用于不同进程间通信。实际上，通常先创建一个管道，再通过fork函数创建另一个子进程。

　　②注意管道是单工的，所以要关闭父子进程中其中的一些fd（如上图所示）。如果需要双向通信，则需要创建2个管道。

【编程实验】父进程写入，子进程读取

//cal_pipe.c

 View Code

【编程实验】模拟管道命令

　　①一个子进程执行命令，将命令执行结果写入管道

　　②另一个子进程从管道中读取命令执行的结果，然后根据关键字过滤(grep)

　　③分析命令：cat /etc/passwd | grep root。执行该命令时，实际上有3进程：父进程shell，执行cat的子进程和执行grep的子进程！这与本例模拟的情景是一样的，由cat的子进程执行结果写入管道，grep的子进程从管道中读取出来！

 //cmd_pipe.c

复制代码

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

char* cmd1[3] = {"/bin/cat", "/etc/passwd", NULL};
char* cmd2[3] = {"/bin/grep", "root", NULL};
//char* cmd2[3] = {"wc", "-l", NULL}; //统计多少用户
int main(void)
{
    int fd[2];

    if(pipe(fd) < 0){
        perror("pipe error");
        exit(1);
    }

    int i = 0;
    pid_t pid;
    //创建进程扇：1个父进程和2个子进程
    for(; i<2; i++){
        pid = fork();
        if(pid < 0){
            perror("fork error");
            exit(1);
        }else if(pid == 0){ //child process
            if(i == 0){ //第1个子进程，负责往管道写入数据
                close(fd[0]); //关闭读端   
                
                //注意cat命令默认输出是标准输出(屏幕)，因此需输重定向到管道写端
                //将标准输出重定向到管道写端，cat执行结果会写入管道
                if(dup2(fd[1], STDOUT_FILENO) != STDOUT_FILENO){ //将fd[1]重向定为标准输出
                    perror("dup2 error");
                }
                
                close(fd[1]);//标准输出己重定向到管道写端，fd[1]可以关闭

                //调用exec函数执行cat命令
                if(execvp(cmd1[0], cmd1) < 0){//v数组，p绝对或相对路径
                    perror("execvp error");
                    exit(1);
                }
            }

            if(i == 1){ //第2个子进程，负责从管道读取数据
                close(fd[1]); //关闭写端
                //将标准输入重定向到管道读端，这样grep将从管道读入而不是从标准输入读取
                if(dup2(fd[0], STDIN_FILENO) != STDIN_FILENO){
                    perror("dup2 error");
                }

                close(fd[0]);//标准输入己重定向到管道读端，fd[0]可以关闭

                //调用exec函数执行grep命令
                if(execvp(cmd2[0], cmd2) < 0){
                    perror("execvp error");
                    exit(1);
                }
            }

            break;
        }else{ //parent process
            if( i== 1){ //须等第2个子进程创建完毕
                //父进程要等到子进程全部创建完毕才去回收
                close(fd[0]);
                close(fd[1]);
                wait(0); //回收两个子进程
                wait(0);
            }
        }
    }
    if(pid = fork() < 0){
    
    }

    return 0;
}
/*输出结果：
 root:x:0:0:root:/root:/bin/bash
 operator:x:11:0:operator:/root:/sbin/nologin
*/

复制代码

【编程实验】协同进程（两个进程通过两个管道进行双向通信）

　　①父进程向第1个管道写入x和y。

　　②子进程从第1个管道读取x和y。并调用add进行相加。

　　③子进程将计算结果写入第2个管道。

　　④父进程从第2个管道中读取计算结果，并输出。

//add.c ==> 需单独编译成add.o的可执行文件

复制代码

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char* argv[])
{
    int x = 0, y = 0;
    if(read(STDIN_FILENO, &x, sizeof(int)) < 0){
        perror("read error");
    }
    if(read(STDIN_FILENO, &y, sizeof(int)) < 0){
        perror("read error");
    }

    int result = x + y;

    if(write(STDOUT_FILENO, &result, sizeof(int)) != sizeof(int)){
        perror("write error");
    }

    return 0;
}

复制代码

//co_process.c ==> 编译成可执行文件

复制代码

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int fda[2], fdb[2];

    //创建两个管道，以实现双工操作
    if( (pipe(fda) < 0) || (pipe(fdb) <0) ){
        perror("pipe error");
        exit(1);
    }

    pid_t pid;
    pid = fork();
    if(pid < 0){
    }else if(pid == 0){//child process
        /*
         *(1)子进程负责从管道a中读取父进程写入的参数x和y
         *(2)通过exec函数去调用bin/add程序进行累加
         *(3)将累加的结果写入到管道b。
         */
        close(fda[1]);//只能从a管道读取
        close(fdb[0]);//只能向b管道写入

        //将标准输入重定向到管道a的读端，则
        //(add程序将从管道a的读端读取累加参数x和y)
        if(dup2(fda[0], STDIN_FILENO) != STDIN_FILENO){
            perror("dup2 error");
        }
        //将标准输出重定向到管道b的写端，则
        //(add程序累加后的结果会写入管道b中)
        if(dup2(fdb[1], STDOUT_FILENO) != STDOUT_FILENO){
            perror("dup2 error");
        }

        close(fda[0]); //重定向完毕，可以关闭
        close(fdb[1]);

        if(execlp("bin/add", "bin/add", NULL) < 0){
            perror("execlp error");
            exit(1);
        }
    }else{ //parent process
        /*
         *(1)从标准输入读取参数x和y
         *(2)将x和y写入管道a
         *(3)从管道b中读取累加结果并输出
         */
        close(fda[0]);
        close(fdb[1]);

        int x, y;
        //(1)读取累加参数x和y
        printf("please input x and y: ");
        scanf("%d %d", &x, &y);
        //(2)将x和y写入管道a
        if(write(fda[1], &x, sizeof(int)) != sizeof(int)){
            perror("write error");
        }
        if(write(fda[1], &y, sizeof(int)) != sizeof(int)){
            perror("write error");
        }

        //(3)从管道b中读取结果（注意管道中无数据时会阻塞！）
        int result;
        if(read(fdb[0], &result, sizeof(int)) < 0){
            perror("read error");
        }else{
            printf("add result is %d\n", result);
        }

        close(fda[1]);
        close(fdb[0]);
        wait(0);
    }
    return 0;
}

复制代码

2.3 管道的特性

（1）通过打开两个管道来创建一个双向的管道

（2）管道是阻塞性的，当进程从管道中读取数据，若没有数据进程会阻塞。

（3）当一个进程往管道中不断地写入数据，但是没有进程去读取数据，此时只要管道没有满是可以了，但若管道放满数据时则会报错。

（4）不完整管道

　　①当读一个写端己关闭的管道时，在所有数据被读取后，read返回0，以表示到达了文件的尾部。

　　②如果写一个读端己被关闭的管道，则产生信号SIGPIPE，如果忽略该信号或捕捉该信号并从处理程序返回，则write返回-1，同时errno设置为EPIPE。

【编程实验】读一个写端己关闭的管道

//broken_pipe_r.c

复制代码

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/*
 *不完整管道：读取一个写端己经关闭的管道
 */
int main()
{
    int fd[2];
    if(pipe(fd) < 0){
        perror("pipe error");
        exit(1);
    }

    pid_t pid;
    if((pid = fork()) < 0){
        perror("fork error");
        exit(1);
    }else if (pid > 0){ //parent process
        //父进程从不完整管道中读取数据
        
        close(fd[1]);
 
        sleep(5);//等待子进程将管道的写端关闭
        
        while(1){
            char c;
            if(read(fd[0], &c, 1) == 0){
                printf("\nwrite-end of pipe closed.\n");
                break;
            }else{
                printf("%c", c);
            }
        }

        close(fd[0]);
        wait(0);
    }else{ //child process
        //子进程负再将数据写入管道
        close(fd[0]);
        char* s = "12345";
        write(fd[1], s, strlen(s)*sizeof(char));

        //写入数据后关闭管道的写端-->变成不完整
        //管道，但要确保在父进程读管道之前管道的写端被关闭！
        close(fd[1]);
    }
    return 0;
}
/*输出结果
 12345
 write-end of pipe closed.
 */

复制代码

【编程实验】写一个读端己关闭的管道

//broken_pipe_w.c

复制代码

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <errno.h>

/*
 *不完整管道：写一个读端己被关闭的管道
 */

//信号处理函数
void sig_handler(int signo)
{
    if(signo == SIGPIPE){
        printf("SIGPIEP occured\n");
    }
}

int main(void)
{
    //注册信号处理函数
    if(signal(SIGPIPE, sig_handler) == SIG_ERR){
        perror("signal sigpipe error");
        exit(1);
    }
    int fd[2];
    if(pipe(fd) < 0){
        perror("pipe error");
        exit(1);
    }

    pid_t pid;
    if((pid = fork()) < 0){
        perror("fork error");
        exit(1);
    }else if(pid > 0){ //parent process       
        //父进程注册信号处理函数
        if(signal(SIGPIPE, sig_handler) == SIG_ERR){
            perror("signal sigpipe error");
            exit(1);
        }

        //父进程负责将数据写入不完整管道（读端关闭）中
        sleep(5);//让子进程先运行，以保证读端关闭

        close(fd[0]);

        char* s = "12345";
        int len = strlen(s) * sizeof(char);
        if(write(fd[1], s, len ) != len){
            fprintf(stderr, "%s, %s\n", strerror(errno),
                   (errno == EPIPE) ? "EPIPE": ", unknow");
        }

        close(fd[1]);
        wait(0);

    }else{ //child process
        close(fd[0]);
        close(fd[1]);
    }
    return 0;
}
/*输出结果：
 SIGPIEP occured
 Broken pipe, EPIPE
 */

复制代码

2.4 标准库中的管道操作

头文件

#include <stdio.h>

函数

FILE* popen(const char* cmdstring, const char* type);

参数

cmdstring：要执行的命令行参数。

type：r或w。

　　①如果type为r，则表示由子进程exec(cmdstring)，结果写入管道(子进程内部会将标准输出重定向到管道写端），父进程从管道中读取命令的执行结果。

　　②如果type为w，则表示父进程将数据写入管道，子进程从管道中读取数据作为命令执行的输入(内部将标准输入重定到到管道的读端)。

返回值

成功返回文件指针，出错返回NULL

功能

通过创建一个管道,调用fork()产生一个子进程，然后由子进程执行cmdstring命令。

函数

int pclose(FILE* fp);

返回值

cmdstring的终止状态，出错返回-1

功能

关闭管道

备注

　　①使用popen()创建的管道必须使用pclose()关闭。其实popen/pclose和标准文件输入/输出流中的fopen/fclose十分相似。

　　②封装管道的常用操作。

【编程实验】利用标准库操作管道的读写

//popen_rw.c

复制代码

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

/*利用管道操作文件*/

int main(void)
{
    FILE* fp;
    //命令执行的结果放置在fp指向的结构体缓存中
    fp = popen("cat /etc/passwd", "r");
    
    char buf[512];
    memset(buf, 0, sizeof(buf));
    while(fgets(buf, sizeof(buf), fp) != NULL){
        printf("%s", buf);
    }

    pclose(fp);

    printf("-----------------------------------------\n");
    //为wc命令提供统计的数据
    fp = popen("wc -l", "w");
    //向fp指向的缓存写入数据（因为type为"w"，所以这些数据会被写入管道中）
    fprintf(fp, "line1\nline2\nline3\n");//提供3行的数据，作为wc要统计的数据来源！
    pclose(fp);

    return 0;
}

复制代码

2.5 命令管道（FIFO）

（1）FIFO的创建

头文件

#include <sys/types.h>

#include <sys/stat.h>

函数

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

参数

①pathname：要创建的管道文件名

②mode：权限（mode % ~umask）

返回值

(1)成功返回0，出错返回-1

(2)FIFO相关出错信息

　　①EACCES(无存取权限)            ②EEXIST(指定文件不存在)

　　③ENAMETOOLONG(路径名太长)      ④ENOENT(包含的目录不存在)

　　⑤ENOSPC(文件系统剩余空间不足)  ⑥ENOTDIR(文件路径无效)

　　⑦EROFS(指定的文件存在于只读文件系统中)

备注

 

（2）注意事项

　　①只要对FIFO有适当访问权限，FIFO可用在任何两个没有任何关系的进程之间通信。

　　②本质上内核中的一块缓存，其在文件系统中以一个特殊的设备文件（管道文件）存在。

　　③在文件系统中只有一个索引块存放文件的路径，没有数据块，所有数据存放在内核中。

　　④命名管道必须读或写同时打开，否则单独读或单独写会引发阻塞。

　　⑤命令mkfifo创建命名管道(命令内部调用mkfifo函数)

　　⑥对FIFO的操作与操作普通文件一样。

　　⑦一旦己经用mkfifo创建一个FIFO，就可以用open打开它，一般的文件I/O函数（close、read、write和unlink等）都可用于FIFO。

【编程实验】读写管道文件

（1）运行本例子中的两个进程之前，必须先mkfifo创建一个命名管道文件（如s.pipe）

（2）不管先运行读还是写的进程。如果命名管道只被打开一端（读或写），则另一个进程会被阻塞。可以通过先运行读或写进程来观察进程被阻塞的现象。

//fifo_write.c ==>编译成单独的可执行文件

复制代码

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>

/*向命名管道写入数据*/

int main(int argc, char* argv[])
{
    if(argc < 2){
        printf("usage: %s fifo\n", argv[0]);
        exit(1);
    }

    printf("open fifo write...\n");
    //打开命名管道
    int fd = open(argv[1], O_WRONLY);
    if( fd < 0 ){
        perror("open error");
        exit(1);
    }else{
        printf("open fifo success: %d\n", fd);
    }

    char* s = "1234567890";
    size_t size = strlen(s);
    if(write(fd, s, size) != size){
        perror("write error");
    }

    close(fd);

    return 0;
}
/*输出结果：
 [root@localhost]# bin/fifo_write s.pipe //要先mkfifo s.pipe创建命名管道文件
 open fifo write...
 open fifo success: 3
 */

复制代码

//fifo_read.c  ==>编译成单独的可执行文件

复制代码

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <memory.h>

/*从命名管道中读取数据*/

int main(int argc, char* argv[])
{
    if(argc < 2){
        printf("usage: %s fifo\n", argv[0]);
        exit(1);
    }

    printf("open fifo read...\n");
    //打开命名管道
    int fd = open(argv[1], O_RDONLY);
    if(fd < 0){
        perror("open error");
        exit(1);
    }else{
        printf("open file sucess: %d\n", fd);
    }

    //从命名管道中读取数据
    char buf[512];
    memset(buf, 0, sizeof(buf));
    while(read(fd, buf, sizeof(buf)) < 0){
        perror("read error");
    }
    printf("%s\n", buf);

    close(fd);

    return 0;
}
/*输出结果：
 [root@localhost]# bin/fifo_read s.pipe
 open fifo read...
 open file sucess: 3
 1234567890
 */

复制代码

2.6 匿名和命令管道的读写

（1）匿名管道和命名管道读写的相同点

相同点

说明

阻塞特性

默认都是阻塞性读写

网络通信

都适用于socket的网络通信

阻塞不完整管道

①单纯读时，在所有数据被读取后，read返回0，以表示到达了文件尾部。

②单纯写时，则产生信号SIGPIPE，如果忽略该信号或捕捉该信号并从处理程序返回，则write返回-1，同时errno设置为EPIPE。

阻塞完整管道

①单纯读时，要么阻塞，要么读取到数据

②单纯写时，写到管道满时会出错

非阻塞不完整管道

①单纯读时直接报错

②单纯写时，则产生信号SIGPIPE，如果忽略该信号或捕捉该信号并从处理程序返回，则write返回-1，同时errno设置为EPIPE。

非阻塞完整管道

①单纯读时直接报错。

②单纯写时，写到管道满时会出错。

（2）匿名管道和命名管道读写的不同点

不同点

说明

打开方式

打开方式不一致

设置阻塞特性

①pipe通过fcntl系统调用来设置O_NONBLOCK来设置非阻塞性读写。

②FIFO通过fcntl系统调用或者open函数来设置非阻塞性读写。

 

原创连接：https://www.cnblogs.com/5iedu/p/6579907.html

 

小坏坏_
关注
专栏目录
IPC之十：使用共享文件进行进程间通信的实例
whowin
12-26 1139
IPC 是 Linux 编程中一个重要的概念，IPC 有多种方式，常用的 IPC 方式有管道、消息队列、共享内存等，但其实使用广大程序员都熟悉的文件也是可以完成 IPC 的，本文介绍如何使用共享文件实现进程间通信，本文给出了具体的实例，并附有完整的源代码；本文实例在 Ubuntu 20.04 上编译测试通过，gcc版本号为：9.4.0；本文的实例中涉及多进程编程、文件锁等概念，所以对 Linux 编程的初学者有一些难度，但对于了解 Linux 下共享文件，特别是文件锁的应用，将是非常难得的。
进程间通信方式（一）：管道
初闻
08-13 750
前言         每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核，在内核中开辟一块缓冲区，进程A把数据从用户空间拷到内核缓冲区，进程B再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信。 一、概念         管道是 Unix 中最古老...
进程间通信：匿名管道pipe
JaweG
10-15 509
7.进程通信：pipe/fifo
linux学习笔记-读《Linux编程技术详解》(10)-管道与命名管道
道路与梦想
05-09 1029
当使用管道进行进程的通信时，进程往管道中写入的内容每次都会被添加在管道缓冲区的结束位置。而另一个进程在读取数据的时候，每次都从缓冲区的头部读取数据。由于管道只能在父子进程或兄弟进程间创建，管道只能用于父子进程或兄弟进程间的通信。非父子进程或兄弟进程间的通信可以使用命名管道或消息队列。           int pipe(int filedes[2]);pipe函数将创建一对指向管道i
Linux管道命令
jasonxzy的专栏
08-30 1001
Linux管道命令利用输入/输出重定向 　　在Linux命令行模式中，如果命令所需的输出不是来自键盘，而是来自指定的文件，这就是输入重定向。同理，命令的输出也可以不显示在屏幕上，而是写入到指定文件中，这就是输出重定向。　　接下来看看标准输入/输出重定向在构造一条Linux命令中的实际应用。1.输入重定向和输出重定向 　　# wc home.txt　　第一条命令将文件aa.txt作为wc命令的输入，统计出aa.txt的行数、单词数和字符数。第二条命令将ls命令的输出保存在一个名为home.txt的文件中。如果
学习opencv_学习笔记二
retacn_yue的专栏
11-17 241
第三章初探opencv Opencv的基本数据类型 typedefstructCvPoint { intx; inty; #ifdef__cplusplus CvPoint(int_x= 0, int_y= 0): x(_x), y(_y) {} template&lt;typename_Tp&gt; CvPoint(constcv::Point_&lt;_Tp&gt;&a...
第七章进程间通信1
08-04
本章主要关注管道通信和System V IPC，而完全网络兼容的进程间通信——Socket将在第十三章涉及。 **管道通信**是最简单的进程间通信形式之一。它通过一个共享文件（或称为pipe文件）连接读进程和写进程，允许数据以...
c语言进程间通信 管道,进程间通信--管道
weixin_30100299的博客
05-21 1085
http://blog.csdn.net/deep_explore/article/details/69285302011在网络程序设计中，如果没有进程间通信，那么软件的功能肯定会大打折扣。进程间通信有哪些途径呢？1.信号2.管道3.消息队列4.信号量5.共享内存管道：管道就是将一个程序的输出与另一个程序的输入连接起来的单向通道。它是UNIX/Linux中古老而最广泛的进程间通信的方式。特别是在s...
Linux进程间通信（管道）
最新发布
pythoncjave的博客
02-15 1025
来讲一下这个代码的大致方向，第一部肯定是创建管道，然后就是创建子进程，这里我们是让父进程写子进程读，所以关闭父子进程不需要的fd，写入的一方，fd没有关闭，如果有数据，就读，没有数据就等，写入的一方，fd关闭, 读取的一方，read会返回0，表示读到了文件的结尾，最后关闭父子进程fd，回收子进程。总结管道的特点，理解以前的管道 | ，管道是一个文件–读取–具有访问控制，显示器也是一个文件，父子同时往显示器写入的时候，有没有说一个会等另一个的情况呢，缺乏访问控制。管道是Unix中最古老的进程间通信的形式。
Linux进程间通信详解：管道、信号与IPC系统调用
本PPT专注于第二十四讲Linux操作系统中的进程间通信（IPC）。该部分旨在帮助学习者深入理解Linux系统的进程通信机制，包括其目的与要求，重点难点以及多种通信方式。 首先，课程强调了理解Linux进程通信的重要性，...
数据结构和算法
u010901792的专栏
08-28 238
数据结构和算法 单链表 struct Node { int data; Node *nextNode; }; 创建列表 Node *CreatList() { Node *head,*p,*s; int cycle=1,x; int count=0; head=(Node*)malloc(sizeof(Node)); p=head;...
raw socket （续）
cplusplus
07-20 969
最近在学习raw socket，上一篇文章也成功发送了SYN，使得服务端的状态变为SYN_RECV。 http://blog.csdn.net/lizhia1221/article/details/51946592 因此，就想尝试去模拟TCP三次握手，无非就是发送三个数据包嘛，想想好像挺简单的，然后瞬间打脸了。下面是测试代码：/* 模拟tcp三次握手，然后收到syn+ack之后，内核也会处
1|进程管理 linux l例子
weixin_43846020的博客
12-19 590
案例1：使用pipe()实现父子进程间通信，要求父进程作为写端，子进程作为读端。 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #include <sys/wait.h> int main() { int fd[2];//定义文件描述符数组 int ret=pipe
popen/pclose导致脚本异常终结
wuzhidefeng的博客
07-07 931
pclose导致脚本异常终结
嵌入式学习笔记_Linux（四）——Linux进程通信
Liang_Quan_Huan的博客
11-12 380
Linux进程通信进程间通信概述：1、数据传输 一个进程需要将他的数据发送给另一个进程。2、资源共享 多个进程之间共享同样的资源。3、通知事件 一个进程需要向另一个或一组进程发送消息，通知他们发生了某种时间。4、进程控制 有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有操作，bin能够及时知道他的状态改变 。 进程间通信方式： 1、管道（
《操作系统导论》第5章作业
qq_18431031的博客
07-04 1549
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/wait.h> int x; int main(int argc, char *argv[]) { printf("This program pid is (%d), x is %d\n", (int)getpid(), x); int rc = fork(); ...
Linux 系统调用 文件描述符
Mu_Muxi_的博客
01-03 1401
目录系统调用main.c 先open再forkmain.c 先fork再openmain.c 打印fd的值第一种情况第二种情况用户空间、内核空间系统调用和库函数的区别替换进程test.cexeclexeclpexecleexecvexecvpexecve 系统调用 PCB进程控制块进程描述符==struct task_struct fork是写时拷贝技术，提高了效率 open read write close 操作文件的系统调用 实现在内核中 fopen fread
#include <unistd.h>作用
Java面试辅导-海龟老师
12-30 4511
#include 作用    unix standard header -> unistd.h standard input output header -> stdio.h standard library header -> stdlib.h unistd.h不是c语言的东西，是linux/unix的系统调用，包含了许多 U N I X系统服务的函数原型,例如 r e a d，
Linux网络编程常用头文件--【超全】
小二笙的博客
12-22 3603
原文地址：Linux网络编程常用头文件 sys/types.h：数据类型定义 sys/socket.h：提供socket函数及数据结构 netinet/in.h：定义数据结构sockaddr_in arpa/inet.h：提供IP地址转换函数 netdb.h：提供设置及获取域名的函数 sys/ioctl.h：提供对I/O控制的函数 sys/poll.h：提供socket等待测试机制的函数 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值