POSIX管道

于 2021-07-12 22:56:44 发布
阅读量225 收藏 2
点赞数
分类专栏： Linux环境编程
原文链接：https://blog.csdn.net/code_peak
版权

参考：《UNIX网络编程 · 卷2 : 进程间通信》

PIPE（无名管道）

管道是最初的 Unix IPC 形式，其局限在于其没有名字，只能由有亲缘关系的进程使用。PIPE 使用常用的 read 和 write 函数访问。所有的 Unix 都提供无名管道，提供一个单向数据流（半双工），但是有些版本的 Unix 提供全双工管道。

#include <unistd.h>
int pipe(int fd[2]); //返回值：成功为0，出错为-1

如下展示了单个进程中管道的模样，从图中可以看到，fd[0] 用于读，称为读端，fd[1] 用于写，称为写端，如下图所示：
单个进程中管道
管道由单个进程创建，却很少在单个进程中使用。最经典的用途就是在父子进程中提供通信手段。父进程调用 fork 派生出一个自身副本，如下图：
父子进程中管道1
如果关闭父进程管道的读段，关闭子进程管道的写入端，就会在父子进程间提供了一个单向的数据流。
父子进程中管道2
如果我们需要一个双向的数据流时，必须创建两个管道，每个方向上一个。如下步骤：

  1. 创建管道1（fd[0] 和 fd[1]）和管道2（fd[0] 和 fd[1]）。
  2. 调用 fork 函数，创建子进程。
  3. 父进程关闭管道 1 的读端 fd1[0]
  4. 父进程关闭管道 2 的写端 fd2[1]
  5. 子进程关闭管道 1 的写端 fd1[1]
  6. 子进程关闭管道 2 的读端 fd2[0]

那么最总的管道布局图如下：
父子进程中管道3
那么，我们可以通过这种模型，实现父进程和子进程之间的通信的典型实例，主要功能是：客户端输入一个路径名，把它写入 IPC 通道，服务器从该通道读出路径名，并尝试打开文件读取，读取成功并写入IPC通道，否则响应一个出错消息。客户端再将消息打印出来，实例代码如下：

#include <unistd.h>
#include <stdio.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>

#define MAXLINE 128

void client(int readfd, int writefd)
{
    size_t len;
    ssize_t n;
    char buff[MAXLINE];
    fgets(buff, MAXLINE, stdin);
    len = strlen(buff);
    if (buff[len - 1] == '\n')
        len--;
    write(writefd, buff, len);
    while ((n = read(readfd, buff, MAXLINE)) > 0) //阻塞读
    {
        write(STDOUT_FILENO, buff, n);
    }
}

void server(int readfd, int writefd)
{
    int fd;
    ssize_t n;
    char buff[MAXLINE + 1];
    if ((n = read(readfd, buff, MAXLINE)) == 0)
    {
        printf("EOF read pathname");
        exit(1);
    }
    buff[n] = '\0';
    if ((fd = open(buff, O_RDONLY)) < 0) //出错
    {
        snprintf(buff + n, sizeof(buff) - n, ":cant't open\n");
        n = strlen(buff);
        write(writefd, buff, n);
    }
    else
    {
        while ((n = read(fd, buff, MAXLINE)) > 0)
        {
            write(writefd, buff, n);
        }
        close(fd);
    }
}

int main()
{
    int pipe1[2];
    int pipe2[2];
    pid_t childpid;
    //TODO:返回值判断
    pipe(pipe1);
    pipe(pipe2);
    if ((childpid = fork()) == 0) //子进程
    {
        close(pipe1[1]);
        close(pipe2[0]);
        server(pipe1[0], pipe2[1]); //充当服务器
        exit(0);
    }
    //父进程
    close(pipe1[0]);
    close(pipe2[1]);
    client(pipe2[0], pipe1[1]); //充当客户端

    waitpid(childpid, NULL, 0);

    exit(0);
}

shell 中的管道原理

在上面已经对管道做了详细解释，那么 shell 中的管道是如何运作的呢？
假如在 shell 中输入一个像下面这种命令：

$ who | sort | lp

该 shell 将执行上述步骤创建三个进程和其间的两个管道。还把每个管道的读出端复制到相应的进程的标准输入，把每个管道的写入端复制到相应进程的标准输出，就有了如下这样的管道线：
shell中的管道原理

全双工管道

上面提到，某些 Unix 的 pipe 是提供全双工的，除此之外，许多内核都提供的 socketpair 函数也是全双工的。那么全双工管道到底提供什么？
首先看一下半双工管道：
半双工管道
再看全双工管道：
全双工管道
这里的全双工管道是由两个半双工管道构成的。写入 fd[1] 的数据只能从 fd[0] 读出，写 入 fd[0] 的数据只能从 fd[1] 读出。
可使用单个全双工管道完成双向通信，如下程序：

#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>

int main()
{
    int fd[2];
    int n;
    char c;
    pid_t childpid;
    pipe(fd);
    if ((childpid = fork()) == 0) //子进程
    {
        sleep(1);
        if ((n = read(fd[0], &c, 1)) != 1)
        {
            printf("child:read returned %d", n);
            exit(1);
        }

        printf("child read:%c\n", c);
        write(fd[0], "c", 1);
        exit(0);
    }
    //父进程
    write(fd[1], "p", 1);
    sleep(2);
    if ((n = read(fd[1], &c, 1)) != 1)
    {
        printf("parent:read returned %d", n);
        exit(1);
    }
    printf("parent read:%c\n", c);
    waitpid(childpid, NULL, 0);

    exit(0);
}

在某些 Unix 如 Solaris 2.6 上是全双工的，这份代码可以运行。
然而，遗憾的是，这份代码并不能在 Linux 上正常运行，因为 Linux 上的 pipe 只是半双工的。父进程试图在 fd[1] 端 read 会中止，子进程在 fd[0] 端 write 时中止，并出现错误。

popen/pclode 函数

popen 主要用于创建一个管道并启动另外一个进程，这个进程要么从该管道读出标准输入，要么从该管道写入标准输出。
pclose 主要用于关闭由 popen 创建的标准 I/O 流，等待其中的命令终止，然后返回 shell 的终止状态。

#include <stdio.h>
FILE *popen(const char *command, const char *type); //返回值：成功文件指针，出错NULL
int pclose(FILE *stream); //返回成功则为 shell 终止状态，出错为-1

参数：
command：是一个 shell 命令。popen 在调用进程和所指定的命令之间建立一个管道，由 popen 返回的值是一个标准 I/O FILE 指针，该指针或者用于输入，或者用于输出，取决于 type。
type：如果为 r，调用进程读取 command 的标准输出；如果是 w，调用进程写到 command 的标准输入。
如下使用 popen 函数和 shell 的 cat 命令实例，cat 命令的输出被复制到标准输出。

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

#define MAXLINE 128

int main()
{
    size_t n;
    char buff[MAXLINE];
    char command[MAXLINE];
    FILE *fp;
    fgets(buff, MAXLINE, stdin); //read path name
    n = strlen(buff);
    if (buff[n - 1] == '\n')
        n--;
    snprintf(command, sizeof(command), "cat %s", buff);
    fp = popen(command, "r");
    while (fgets(buff, MAXLINE, fp) != NULL)
    {
        fputs(buff, stdout);
    }
    pclose(fp);
    exit(0);
}

在 Linux 下运行结果：

 ./test 
/etc/shadow
cat: /etc/shadow: Permission denied

虽然得到一个出错的信息，但是调用是成功的，因为 cat 将出错消息写到标准错误输出，调用进程读取到该输出，并打印出来。

FIFO（有名管道）

上面说到 pipe 没有名字，无法用于无亲缘关系的两个进程之间。而 FIFO 类似于管道，其全称 First in first out，是一个单向（半双工）数据流，但是每个 FIFO 都有一个路径名与之关联，也就支持了无亲缘关系的进程访问同一个 FIFO，而 FIFO 也随之被称为又名管道。
FIFO 由 makfifo 函数创建：

#include <sys/types.h>
#include <sys/stat.h>

int mkfifo(const char *pathname, mode_t mode); //返回值：成功0，出错-1

参数：
pathname：一个普通的 Unix 路径名，作为该 FIFO 的名字。
mode：指定文件权限位，类似于 open 的第二个参数，在 IPC 概念中已经提到过。FIFO 函数已经默认指定 O_CREAT | O_EXCL。所以如果创建一个所指定名字的 FIFO 已存在，返回一个 EEXIST 的错误。如果不希望创建一个新的 FIFO，就改为调用 open 而不是 mkfifo。
所以正确的做法就是：要打开一个已存在的 FIFO 或 创建一个新的 FIFO，应先调用 mkfifo，再检查它是否返回 EEXIST 错误，若返回该错误则改为调用 open。
我们也可以从 shell 命令创建 FIFO，使用 mkfifo 命令即可。
创建出一个 FIFO 后，必须打开来读或者写，所用的可以是 open 函数或者标准 I/O 函数，如 fopen。FIFO 不能打开来即读又写，因为它是半双工的。
对 pipe 或 FIFO 的 write 总是向末尾添加数据，read 总是从头返回数据。如果对 pipe 或 FIFO 调用 lseek，将返回 ESPIPE 错误。
现在重新使用 FIFO 编写上面的客户端-服务器的程序。使用两个 FIFO代替两个 PIPE。

#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/wait.h>

#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
#define FIFO1 "/tmp/fifo.1"
#define FIFO2 "/tmp/fifo.2"
#define MAXLINE 128

void client(int readfd, int writefd)
{
    size_t len;
    ssize_t n;
    char buff[MAXLINE];
    fgets(buff, MAXLINE, stdin);	//读取输入的文件名
    len = strlen(buff);
    if (buff[len - 1] == '\n')
        len--;
    write(writefd, buff, len);	//写入到管道中
    while ((n = read(readfd, buff, MAXLINE)) > 0) //从管道中读
    {
        write(STDOUT_FILENO, buff, n);
    }
}

void server(int readfd, int writefd)
{
    int fd;
    ssize_t n;
    char buff[MAXLINE + 1];
    if ((n = read(readfd, buff, MAXLINE)) == 0) //服务器读取客户端管道中发来的文件名
    {
        printf("EOF read pathname");
        exit(1);
    }
    buff[n] = '\0';
    if ((fd = open(buff, O_RDONLY)) < 0) //打开文件
    {
        snprintf(buff + n, sizeof(buff) - n, ":cant't open\n");
        n = strlen(buff);
        write(writefd, buff, n);
    }
    else
    {
        while ((n = read(fd, buff, MAXLINE)) > 0)
        {
            write(writefd, buff, n);	//读取内容写入管道中
        }
        close(fd);
    }
}

int main()
{
    int readfd, writefd;
    pid_t childpid;
    if ((mkfifo(FIFO1, FILE_MODE) < 0) && (errno != EEXIST))
        printf("can't create %s\n", FIFO1);
    if ((mkfifo(FIFO2, FILE_MODE) < 0) && (errno != EEXIST))
    {
        unlink(FIFO1);
        printf("can't create %s\n", FIFO2);
    }

    if ((childpid = fork()) == 0) //子进程
    {
        readfd = open(FIFO1, O_RDONLY, 0);
        writefd = open(FIFO2, O_WRONLY, 0);

        server(readfd, writefd);
        exit(0);
    }
    //父进程
    writefd = open(FIFO1, O_WRONLY, 0);
    readfd = open(FIFO2, O_RDONLY, 0);

    client(readfd, writefd);

    waitpid(childpid, NULL, 0);

    close(readfd);
    close(writefd);

    unlink(FIFO1);
    unlink(FIFO2);
    exit(0);
}

需要注意的是：创建打开一个 FIFO 则需要在调用 mkfifo 后再调用 open。管道在所有进程都关闭它之后自动消息。FIFO 的名字只有通过调用 unlink 才能从文件系统中删除。这样的好处就是：FIFO 在文件系统中有一个名字，该名字允许某个进程创建一个 FIFO，与它无关的另一个进程来打开这个 FIFO。
有名管道FIFO
如果没有正确的使用 FIFO 会发生问题。比如我们将上面的父进程中两个 open 调用顺序互换，程序就不能工作，因为当没有任何进程打开某个 FIFO 来写，那么打开该 FIFO 来读的进程将阻塞。父子进程都将打开一个 FIFO 来读，但是当时并没有任何进程已打开该文件来写，父子进程将阻塞，形成死锁。
因为 FIFO 的 open 使用 O_RDONLY 标志将阻塞到另一个只写 O_WRONLY 标志打开该 FIFO 为止。
再来看一个无亲缘关系的进程的例子：
客户端：

#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/wait.h>

#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
#define FIFO1 "/tmp/fifo.1"
#define FIFO2 "/tmp/fifo.2"
#define MAXLINE 128

void client(int readfd, int writefd)
{
    size_t len;
    ssize_t n;
    char buff[MAXLINE];
    fgets(buff, MAXLINE, stdin);
    len = strlen(buff);
    if (buff[len - 1] == '\n')
        len--;
    write(writefd, buff, len);
    while ((n = read(readfd, buff, MAXLINE)) > 0) //阻塞读
    {
        write(STDOUT_FILENO, buff, n);
    }
}

int main()
{
    int readfd, writefd;
    writefd = open(FIFO1, O_WRONLY, 0);
    readfd = open(FIFO2, O_RDONLY, 0);

    client(readfd, writefd);

    close(readfd);
    close(writefd);

    unlink(FIFO1);
    unlink(FIFO2);

    return 0;
}

服务器：

#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/wait.h>

#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
#define FIFO1 "/tmp/fifo.1"
#define FIFO2 "/tmp/fifo.2"
#define MAXLINE 128

void server(int readfd, int writefd)
{
    int fd;
    ssize_t n;
    char buff[MAXLINE + 1];
    if ((n = read(readfd, buff, MAXLINE)) == 0)
    {
        printf("EOF read pathname");
        exit(1);
    }
    buff[n] = '\0';
    if ((fd = open(buff, O_RDONLY)) < 0) //出错
    {
        snprintf(buff + n, sizeof(buff) - n, ":cant't open\n");
        n = strlen(buff);
        write(writefd, buff, n);
    }
    else
    {
        while ((n = read(fd, buff, MAXLINE)) > 0)
        {
            write(writefd, buff, n);
        }
        close(fd);
    }
}

int main()
{
    int readfd, writefd;
    if ((mkfifo(FIFO1, FILE_MODE) < 0) && (errno != EEXIST))
        printf("can't create %s\n", FIFO1);
    if ((mkfifo(FIFO2, FILE_MODE) < 0) && (errno != EEXIST))
    {
        unlink(FIFO1);
        printf("can't create %s\n", FIFO2);
    }

    readfd = open(FIFO1, O_RDONLY, 0);
    writefd = open(FIFO2, O_WRONLY, 0);

    server(readfd, writefd);

    return 0;
}

PIPE 和 FIFO 的非阻塞属性

PIPE 和 FIFO 的打开、读入和写入还有一些属性，比如将管道设置为非阻塞。
（1）调用 open 时可指定 O_NONBLOCK 标志。如下：

writefd = open(FIFO1, O_WRONLY | O_NONBLOCK, 0);

（2）若描述符已经打开，可以调用 fcntl 以启用 O_NONBLOCK 标志，在 PIPE 中来说，必须使用这种技术，因为其没有 open 调用。在使用 fcntl 时，先使用 F_GETFL 命令取得当前文件状态标志，将它和 O_NONBLOCK 标志按位或后，再使用 F_SETFL 命令存储这些文件标志。

int flags;
if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
	err_sys("F_GETFL error.");
flags |= O_NNONBLOCK;
if (fcntl(fd, F_SETFL, flags) < 0)
    err_sys("F_SETFL error");

非阻塞标志对管道 PIPE 和 FIFO 的影响：
非阻塞标志对管道PIPE和FIFO的影响
write 操作是原子性的，若有两个进程差不多同时向一个 PIPE 或者 FIFO 写，那么要么先写入来自第一个进程的所有数据，再写第二个进程的所有数据，要么颠倒，系统不会混杂写。O_NONBLOCK 标志对对于其原子性没有影响。
如果向一个没有为读打开着的 PIPE 或者 FIFO 写入，那么内核将产生一个 SIGPIPE 信号，若进程没有捕捉也没有忽略，默认行为将是终止进程。

PIPE 和 FIFO 的限制

系统加于 PIPE 和 FIFO 的唯一限制为：
OPEN_MAX 一个进程在任意时刻打开的最大描述符数（Posix 要求至少为 16）
PIPE_BUF 可原子地写往一个 PIEP 或 FIFO 的最大数据量（Posix 要求至少为512）。
OPEN_MAX 的值可通过调用 sysconf 函数查询。它通常可通过执行 ulimit 命令或 limit 命令从 shell 中修改。也可通过调用 setrlimit 函数从一个进程中修改。
PIPE_BUF 的值通常定义在头文件中，但是 Posix 认为它是一个路径名变量。意味着它的值可以随所指定的路径名而变化（只对 FIFO 而言， 因为 PIPE 没有名字），因为不同的路径名可以落在不同的文件系统上，而这些文件系统可能有不同的特征。于是 PIPE_BUF 的值可在运行时通过调用 pathconf 或 fpathconf 取得。如下实例：

int main(int argc, char **argv)
{
    if (argc != 2)
    {
        printf("usage: pipeconf <pathname>");
        exit(1);
    }

    printf("PIPE_BUF = %ld, OPEN_MAX = %ld\n",
           pathconf(argv[1], _PC_PIPE_BUF), sysconf(_SC_OPEN_MAX));
    exit(0);
}
code_peak
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Posix管道基本知识
zhoushuaiyin的专栏
12-23 1258
1. 基本信息 管道是最早的IPC形式，一般可以分为管道和FIFO（命名管道）两类，使用通常的read和write进行读写。管道可以分为全双工和半双工管道。不同版本的Unix提供了不同的实现。SVR4的pipe创建的为全双工管道，而posix1标准则为半双工管道。一般是先全双工管道使用socketpair函数较为可靠。 2. pipe、popen、pclose #include int p
进程间通信——POSIX 有名信号量与无名信号量
资料qun832218493
06-24 494
Linux服务器相关视频 服务端的网络并发，详细解读网络io与线程进程 挑战360°无死角讲解 进程管理，调度器的5种实现 LinuxC++后台服务器架构师免费学习地址 前言 在 POSIX 系统中，进程间通信是一个很有意思的话题。 POSIX信号量进程是3种 IPC(Inter-Process Communication) 机制之一，3种 IPC 机制源于 POSIX.1 的实时扩展。Single UNIX Specification 将3种机制（消息队列，信号量和共享存储）置于可选部分..
笔记：进程间通信——消息传递(管道、FIFO、posix消息队列)
见贤思齐
06-19 2490
管道的创建, fd[0]：从管道读；fd[1]：向管道写 管道是单个进程创建的，它却很少在单个进程内使用。管道的典型用途是：两个进程（一个父进程，一个子进程）提高进程间通信的手段。 步骤： 首先，父进程创建一个管道，fork一个自进程（子进程中也有该管道，管道相当与文件，子进程可以共享父进程的？）； 然后，父进程关闭管道的读出端，子进程关闭同一个管道的写入端。 这样父子进程间变形成了一个
POSIX函数
beyond__devil的博客
12-22 5356
POSIX: 简介： 该模块包含了定义在 IEEE 1003.1(POSIX.1)标准文档里的函数的接口，通过其它手段无法访问。 警告： 通过POSIX函数，可以检索很多敏感数据，例如：posix_getpwnam()以及其它函数。当开启了安全模式，POSIX函数并不会执行任何的权限检测。因此，当正在上述的环境下操作，强烈建议关闭POSIX扩展(在配置行中使用 '--disable
POSIX1003标准文档
01-06
3. **Shell命令和脚本编程**：POSIX标准定义了一个称为“POSIX shell”的命令解释器，即`/bin/sh`，它支持一系列基本的命令和控制结构，如管道`|`，重定向`>`，循环`for`和条件语句`if`等，用于编写简单的自动化脚本...
posix ipc python库源码
11-24
POSIX IPC（Interprocess Communication）是操作系统提供的一种进程间通信机制，主要在类Unix系统如Linux、macOS中使用。Python中的`posix_ipc`库是一个用于实现这些通信机制的模块，它提供了对信号量、消息队列、...
mrsh：最小的POSIX外壳
02-05
2. **Shell的基本功能**：包括但不限于命令行解析、环境变量管理、脚本执行、管道（pipe）、重定向（redirect）以及信号处理等。在mrsh中，这些功能将遵循POSIX标准，保证在不同系统上的行为一致性。 3. **精简与...
test-load.zip_c_child_posix
09-23
POSIX提供了多种IPC机制，如管道（pipe）、套接字（socket）、共享内存、信号量等，以便进程间协调工作。 4. **错误处理**：在实际编程中，需要考虑`fork()`和`exec()`可能出现的错误，如内存不足、权限问题等。...
并行计算 + Posix
09-19
并行计算和Posix编程是计算机科学中的两个关键领域，它们在高性能计算、分布式系统以及大规模数据处理中扮演着重要角色。本教材旨在为初学者提供一个深入理解这两个主题的平台，通过学习，读者可以掌握如何利用多核...
[Linux] 进程间通信--管道 pipe 函数详解 (出自 360百科)
anchang7456的博客
12-17 159
函数 　　pipe我们用中文叫做管道。 　　以下讲解均是基于Linux为环境： 简介 　　所需头文件 #include<unistd.h> 　　函数原型 int pipe(int fd[2]) 　　函数传入值 fd[2]:管道的两个文件描述符，之后就是可以直接操作这两个文件描述符 　　返回值 成功 0 　失败 -1 什么是管...
Linux pipe
cation的专栏
04-11 7193
Linux pipe发布时间：2008-03-21 00:00:00<!--google_ad_client = "pub-8181890405792697";google_ad_width = 336;google_ad_height = 280;google_ad_format = "336x280_as";google_ad_type = "tex
linux管道pipe详解
热门推荐
oguro的博客
12-23 9万+
管道 管道的概念： 管道是一种最基本的IPC机制，作用于有血缘关系的进程之间，完成数据传递。调用pipe系统函数即可创建一个管道。有如下特质： 1. 其本质是一个伪文件(实为内核缓冲区) 2. 由两个文件描述符引用，一个表示读端，一个表示写端。 3. 规定数据从管道的写端流入管道，从读端流出。 管道的原理: 管道实为内核使用环形队列机制，借助内核缓冲区(4k)实现。 管道的局限性
POSIX标准（stdio,pipes）
xyc1211的博客
05-08 508
可移植性操作系统接口 POSIX标准 包括了系统应用程序接口（API），以及实时扩展（C语言）。 目的是定义了标准的基于UNIX操作系统的系统接口和环境来支持源代码级的可移植性 不同操作系统的实现可能不同 标准I/O流 stderr, stdin, stdout 在程序启动时，自动打开文件描述符： 0 标准输入（用于读取常规输入） 1 标准输出（用于常规输出） 默认显示屏 默认是行缓冲，遇到‘\n’，才向外输出内容 2 标准错误（用于诊断信息输出） 默认显示屏 没有缓冲的，它立即输出 pipes 管
Linux进程间通信——管道 pipe 详解
electrocrazy的博客
11-26 2318
详细介绍linux进程间通信方式之一的pipe的相关知识
实现一个管道通信程序
一只博客
08-05 4175
2)实现一个管道通信程序 由父进程创建一个管道，然后再创建三个子进程，并由这三个子进程利用管道与父进程之间进行通信：子进程发送消息，父进程等待三个子进程全部发完消息后再接收信息。通信的具体内容可根据自己的需要随意设计，要求能试验阻塞型读写过程中的各种情况，测试管道的默认大小，并且要求利用Posix信号量机制实现进程间对管道的互斥访问。运行程序，观察各种情况下，进程实际读写的字节数以...
管道的使用---参见Windows核心编程
farrellzhang的专栏
02-13 1006
管道也是一种重要的进程间通信方式，最近看了WINDOWS核心编程里面关于管道的理论及例子，觉得挺有意思，自己模拟着写了一个，其中有些还是不太明白 尤其是服务端中的WaitForSingleObjectEx函数的返回值---WAIT-IO-COMPLETION，欢迎大家指点； 测试时，可将编译的程序复制一份，一个做客户端，一个做服务端就可以，若要退出就在客户端直接发出“quit"，即可。
Posix信号量基本知识
zhoushuaiyin的专栏
12-15 2462
1. 引言 信号量包含一个非负整型变量，其包含一对原子操作，即P/V操作。 P操作：若信号量非负，则P操作将信号量值减1；若信号量为0，则P操作将执行wait操作。 V操作：将信号量值加1。 Linux包含两类信号量： 信号量可分为Posix信号量和System V信号量。今天我们主要学习一下Posix信号量，其有两类形式：命名信号量和无名信号量，其主要区别在于创建和销毁的形式。命名信号
System V 与 POSIX
FireBird的专栏
02-20 6966
System V 以及POSIX 对信号量、共享内存、消息队列等进程之间共享方式提供了自己的解决方案。因此，在学习时难免存在疑惑，到底有什么区别，哪种方式更佳。经过网上搜索各种博客，做出简单的总结。 历史        UNIX两大贡献者贝尔实验室和BSD，在进程之间通信侧重不同，前者基于内核对进程之间的通信手段进行了改进，形成了“System V IPC”，而后者则是基于网络形成了套接字。
posix 1003.
最新发布
07-20
此外，POSIX 1003还定义了一系列环境变量、系统错误码、管道机制等，进一步增强了系统间的统一性和互操作性。 综上所述，POSIX 1003是一种可以跨不同操作系统平台使用的标准接口。它提供了一致的API，促进了可移植...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值