管道读写规则及 PIPE_BUF 涉及的写原子性问题

已于 2024-03-19 10:41:39 修改
阅读量463 收藏 6
点赞数 10
分类专栏： Linux 文章标签： linux
于 2024-03-06 15:16:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chirrupy_hamal/article/details/136504694
版权

结论：
一、当管道内没有数据可读时
O_NONBLOCK disable：read 调用阻塞，直到有可读数据
O_NONBLOCK enable： read 调用返回 -1，errno 值为 EAGAIN

二、当管道已满或者剩余空间不够时
O_NONBLOCK disable：write 调用阻塞，直到有进程读走数据，管道中有足够大的可用空间
O_NONBLOCK enable： write 调用返回 -1，errno 值为 EAGAIN

匿名管道默认是阻塞模式，可通过以下示例修改为非阻塞模式

int flags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, flags | O_NONBLOCK);

命名管道的阻塞模式和非阻塞模式设定参见以下示例

open("fifo", flags | O_NONBLOCK);  //非阻塞
open("fifo", flags);  //阻塞

管道容量

三、
如果所有管道写端对应的文件描述符被关闭，则 read 调用返回 0
如果所有管道读端对应的文件描述符被关闭，则 write 调用会产生信号 SIGPIPE，进而可能导致写进程退出

四、man 7 pipe
1、当要写入的数据量 n <= PIPE_BUF 时，linux 将保证写入的原子性
O_NONBLOCK disable：如果管道中有足够大的可用空间便写入；否则 write 调用阻塞，直到管道中有足够大的可用空间
O_NONBLOCK enable： 如果管道中有足够大的可用空间便写入；否则 write 调用返回 -1，errno 值为 EAGAIN
2、当要写入的数据量 n > PIPE_BUF 时，linux 将不再保证写入的原子性
O_NONBLOCK disable：write 直到将所有数据写入管道后返回，期间可能有其他进程穿插写入
O_NONBLOCK enable： 如果管道已满，write 调用返回 -1，errno 值为 EAGAIN；否则实际写入的数据量为 1 ~ n，即部分写入，期间可能有其他进程穿插写入
3、读数据不会因为读取数据量 n 是否大于 PIPE_BUF 失去原子性

五、综合以上一、二和四1、3，内核会对管道(匿名/命名管道)进行同步与互斥

在这里插入图片描述

验证如下：
1、O_NONBLOCK disable：read 调用阻塞

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

int main(void)
{
  int    fds[2];
  pid_t  pid;
  time_t t;
  char   buf[10] = {0};

  if(0 != pipe(fds))
  {
    perror("pipe error");
    exit(EXIT_FAILURE);
  }

  pid = fork();
  if (-1 == pid)
  {
    perror("fork error");
    exit(EXIT_FAILURE);
  }

  if (0 == pid)
  {
    close(fds[0]);  //关闭读端
    sleep(10);
    write(fds[1], "hello", 5);
    exit(EXIT_SUCCESS);
  }

  close(fds[1]);  //关闭写端
  t = time(NULL);
  read(fds[0], buf, sizeof(buf));
  t = time(NULL) - t;
  printf("receive data: %s, interval time: %ds\n", buf, t);

  waitpid(pid, NULL, 0);

  return 0;
}
/*
 * receive data: hello, interval time: 10s
 */

2、O_NONBLOCK enable：read 调用返回 -1，errno 值为 EAGAIN(11)

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

int main(void)
{
  int    fds[2], flags;
  pid_t  pid;
  char   buf[10] = {0};

  if(0 != pipe(fds))
  {
    perror("pipe error");
    exit(EXIT_FAILURE);
  }

  pid = fork();
  if (-1 == pid)
  {
    perror("fork error");
    exit(EXIT_FAILURE);
  }

  if (0 == pid)
  {
    close(fds[0]);
    sleep(10);
    write(fds[1], "hello", 5);
    exit(EXIT_SUCCESS);
  }

  close(fds[1]);
  flags = fcntl(fds[0], F_GETFL);
  fcntl(fds[0], F_SETFL, flags | O_NONBLOCK);
  if (-1 == read(fds[0], buf, sizeof(buf)))
  {
    perror("read error");
    printf("errno: %d\n", errno);
    waitpid(pid, NULL, 0);
    exit(EXIT_FAILURE);
  }
  printf("receive data: %s\n", buf);

  waitpid(pid, NULL, 0);

  return 0;
}
/*
 * read error: Resource temporarily unavailable
 * errno: 11
 */

3、O_NONBLOCK disable：write 调用阻塞

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

int main(void)
{
  int  fds[2];
  char buf[4096];
  int  count = 0;

  if(0 != pipe(fds))
  {
    perror("pipe error");
    exit(EXIT_FAILURE);
  }

  memset(buf, 'A', sizeof(buf));
  while(1)
  {
    count += write(fds[1], buf, sizeof(buf));
    printf("writed data length: %d\n", count);
  }

  return 0;
}
/*
  writed data length: 4096
  writed data length: 8192
  writed data length: 12288
  writed data length: 16384
  writed data length: 20480
  writed data length: 24576
  writed data length: 28672
  writed data length: 32768
  writed data length: 36864
  writed data length: 40960
  writed data length: 45056
  writed data length: 49152
  writed data length: 53248
  writed data length: 57344
  writed data length: 61440
  writed data length: 65536
  阻塞卡住
 */

4、O_NONBLOCK enable： write 调用返回 -1，errno 值为 EAGAIN

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

int main(void)
{
  int  fds[2], flags;
  char buf[4096];
  int  ret, count = 0;

  if(0 != pipe(fds))
  {
    perror("pipe error");
    exit(EXIT_FAILURE);
  }

  flags = fcntl(fds[1], F_GETFL);
  fcntl(fds[1], F_SETFL, flags | O_NONBLOCK);

  memset(buf, 'A', sizeof(buf));
  while(1)
  {
    ret = write(fds[1], buf, sizeof(buf));
    if (-1 == ret)
    {
      perror("write error");
      printf("errno: %d\n", errno);
      exit(EXIT_FAILURE);
    }

    count += ret;
    printf("writed data length: %d\n", count);
  }

  return 0;
}
/*
  writed data length: 4096
  writed data length: 8192
  writed data length: 12288
  writed data length: 16384
  writed data length: 20480
  writed data length: 24576
  writed data length: 28672
  writed data length: 32768
  writed data length: 36864
  writed data length: 40960
  writed data length: 45056
  writed data length: 49152
  writed data length: 53248
  writed data length: 57344
  writed data length: 61440
  writed data length: 65536
  write error: Resource temporarily unavailable
  errno: 11
 */

5、所有管道写端对应的文件描述符被关闭，read 调用返回 0

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

int main(void)
{
  int    fds[2];
  char   buf[10] = {0};
  int    ret;

  if(0 != pipe(fds))
  {
    perror("pipe error");
    exit(EXIT_FAILURE);
  }

  close(fds[1]);  //此处用单进程验证

  ret = read(fds[0], buf, sizeof(buf));
  printf("receive data len: %d\n", ret);

  return 0;
}
/*
 * receive data len: 0
  */

6、所有管道读端对应的文件描述符被关闭，write 调用会产生信号 SIGPIPE(13，kill -l)

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

void sighandler(int signo)
{
  printf("catch a signal, signum: %d\n", signo);
}

int main(void)
{
  int    fds[2];
  char   buf[10] = {0};
  int    ret;

  if(SIG_ERR == signal(SIGPIPE, sighandler))
  {
    perror("signal error");
    exit(EXIT_FAILURE);
  }

  if(0 != pipe(fds))
  {
    perror("pipe error");
    exit(EXIT_FAILURE);
  }

  close(fds[0]);

  ret = write(fds[1], "hello", 5);
  printf("write ret val: %d\n", ret);

  return 0;
}
/*
 * catch a signal, signum: 13
 * write ret val: -1
 */

7、当要写入的数据量 n > PIPE_BUF 时，linux 将不再保证写入的原子性
O_NONBLOCK disable：write 直到将所有数据写入管道后返回，期间可能有其他进程穿插写入

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

#define PIPE_SIZE  4096
#if 0
// error
#define WRITE_SIZE PIPE_SIZE + 1
#else
// ok
#define WRITE_SIZE PIPE_SIZE
#endif
#define READ_SIZE  PIPE_SIZE + 1

int main(void)
{
  int   fds[2], ofd;
  pid_t pid;
  char  obuf[WRITE_SIZE], c;
  int   len;
  char  ibuf[READ_SIZE] = {0};

  if (0 != pipe(fds))
  {
    perror("pipe error");
    exit(EXIT_FAILURE);
  }

  pid = fork();
  if (-1 == pid)
  {
    perror("fork error");
    exit(EXIT_FAILURE);
  }
  else if (0 == pid)
  {
    close(fds[0]);
    for (c = 'A'; c <= 'M'; c++)
    {
      memset(obuf, c, WRITE_SIZE);
      len = write(fds[1], obuf, WRITE_SIZE);
      printf("child1 write %d bytes to pipe\n", len);
    }
    exit(0);
  }

  pid = fork();
  if (-1 == pid)
  {
    perror("fork error");
    exit(EXIT_FAILURE);
  }
  else if (0 == pid)
  {
    close(fds[0]);
    for (c = 'N'; c <= 'Z'; c++)
    {
      memset(obuf, c, WRITE_SIZE);
      len = write(fds[1], obuf, WRITE_SIZE);
      printf("child2 write %d bytes to pipe\n", len);
    }
    exit(0);
  }

  close(fds[1]);
  ofd = open("test.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
  ibuf[4096] = '\n';

  while (1)
  {
    sleep(1);

    if (0 == (len = read(fds[0], ibuf, PIPE_SIZE)))
      break;

    printf("father read %d bytes from pipe\n", len);

    if (PIPE_SIZE == len)
      len = READ_SIZE;

    if (len != write(ofd, ibuf, len))
    {
      printf("write error, quit\n");
      exit(EXIT_FAILURE);
    }

    printf("father write %d bytes to file 'test.txt'\n", len);
  }

  return 0;
}

异常结果：
在这里插入图片描述
8、读数据不会因为读取数据量 n 是否大于 PIPE_BUF 失去原子性

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

#define PIPE_SIZE  4096
#define WRITE_SIZE PIPE_SIZE
#if 0
#define READ_SIZE  PIPE_SIZE
#else
#define READ_SIZE  PIPE_SIZE + 1
#endif

int main(void)
{
  int   fds[2], ofd;
  char  obuf[WRITE_SIZE], c;
  int   len = 0;
  pid_t pid;
  char  ibuf[READ_SIZE + 1] = {0};

  if (0 != pipe(fds))
  {
    perror("pipe error");
    exit(EXIT_FAILURE);
  }

  pid = fork();
  if (-1 == pid)
  {
    perror("fork error");
    exit(EXIT_FAILURE);
  }
  else if (0 == pid)
  {
    close(fds[1]);

    ofd = open("child1.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    ibuf[READ_SIZE] = '\n';

    while (1)
    {
      if (0 == (len = read(fds[0], ibuf, READ_SIZE)))
        break;

      printf("child1 read %d bytes from pipe\n", len);

      if (READ_SIZE == len)
        len += 1;

      if (len != write(ofd, ibuf, len))
      {
        printf("write error, quit\n");
        exit(EXIT_FAILURE);
      }

      printf("child1 write %d bytes to file 'child1.txt'\n", len);
    }
    exit(0);
  }

  pid = fork();
  if (-1 == pid)
  {
    perror("fork error");
    exit(EXIT_FAILURE);
  }
  else if (0 == pid)
  {
    close(fds[1]);

    ofd = open("child2.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    ibuf[READ_SIZE] = '\n';

    while (1)
    {
      if (0 == (len = read(fds[0], ibuf, READ_SIZE)))
        break;

      printf("child2 read %d bytes from pipe\n", len);

      if (READ_SIZE == len)
        len += 1;

      if (len != write(ofd, ibuf, len))
      {
        printf("write error, quit\n");
        exit(EXIT_FAILURE);
      }

      printf("child2 write %d bytes to file 'child2.txt'\n", len);
    }
    exit(0);
  }

  for (c = 'A'; c <= 'Z'; c++)
  {
    memset(obuf, c, WRITE_SIZE);
    len += write(fds[1], obuf, WRITE_SIZE);
    printf("father write %d bytes to pipe\n", len);
  }

  close(fds[1]);

  waitpid(-1, NULL, 0);
  waitpid(-1, NULL, 0);

  return 0;
}
chirrupy_hamal
关注
  • 10
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux中的PIPE_SIZE与PIPE_BUF，管道最大写入值问题
judwenwen2009的专栏
03-08 2万+
现在开发的项目是从solaris到linux的应用移植。经常用到popen函数，使用8192字节的数组读取popen输出，但没有进行溢出判断。 刚开始认为是一个简单的内存越界，但对popen和PIPE调查以后，疑惑越来越多了。 1）问题的引出 popen使用管道来记录被调用命令的输出，那么popen的最大写入字节数必然是管道的最大值。 使用linux的ulimit -a来查看系统限制：
ASM.rar_add buf1_buf2
09-24
已知BUF1,BUF2字节单元中各存放一个无符号数，编写程序完成下述功能： 若两个数中一个是奇数一个是偶数，则奇数存入BUF1单元，偶数存入BUF2单元。 若两个数均为奇数，则分别加1后存回原单元 若两个数均为偶数，则不做任何操作。
STM32F103ZET6单片机内部Flash读写实验例程源码.zip
03-20
STM32F103ZET6单片机内部Flash读写实验例程源码 main() { u8 i=0; u8 key; u8 read_buf[TEXTLEN]; SysTick_Init(72); NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //中断优先级分组 分2组 LED_Init(); USART1_Init(9600); TFTLCD_Init(); //LCD初始化 KEY_Init(); while(1) { key=KEY_Scan(0); if(key==KEY_UP) { STM32_FLASH_Write(STM32_FLASH_SAVE_ADDR,(u16*)text_buf,TEXTLEN); printf("写入数据为：%s\r\n",text_buf); LCD_ShowString(10+6*8,130,tftlcd_data.width,tftlcd_data.height,16,(u8 *)text_buf); } if(key=
bsl.rar_CSL_buf.h_evmdm642bsl_seed_vpm 642 b
09-24
SEED的VPM642测试程序-板级支持库
xfs_inode_buf.rar_The Given
09-21
Inode location information. Stored in the inode and passed to xfs_imap_to_bp() to get a buffer and dinode for a given inode.
xfs_buf_item.rar_V2
09-24
xfs buf log format size for Linux v2.13.6.
管道PIPE_BUF说明
冰冻三尺非一日之寒
06-17 4248
管道PIPE_BUF说明    FIFO被称为命名管道。PIPE也是管道。由于pipe和FIFO本质上都是管道，不同点就是创建方式不一样、FIFO多个进程使用（可以没有共同祖先）、FIFO多个进程通信。因此，FIFO的测试demo就不多介绍了。本博客主要记录管道的PIPE_BUF,即管道的缓存大小。PIPE——BUF    POSIX.1规定当写入管道的长度小于PIPE_BUF字节时必须是原子的：...
Linux进程通信-----管道通信
qq_46135211的博客
02-24 370
Linux管道通信
Linux操作系统之PIPE_BUF——父进程读出数据不相互交叉的问题
nanke_4869的博客
10-20 1209
问题描述： 常量PIPE_BUF(在limits.h中定义)规定了内核的管道缓冲区大小，为4096byte。 父进程创建的3个子进程同时写一个管道，要求写入的字节数超过PIPE_BUF，父进程从管道读出的子进程写入的数据不能相互交叉。 代码如下： #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; #include &lt;unist...
linux 管道的创建和读写 pipe
liuwg1226的专栏
05-23 5156
1、管道的创建 #include <unistd.h> int pipe(int pipefd[2]); linux下创建管道可以通过函数pipe来完成。该函数如果调用成功，数组中将包含两个新的文件描述符。 管道两端可分别用描述符fd[0] 以及fd[1]来描述。需要注意的是，管道两端的任务是固定的，一端只能用于读，由描述符fd[0]表示，称其为管道读端； 另一端只能用于写，由描述符fd[1]来表示，称其为管道写端。如果试图从管道写端读数据，或者向管道读端写数据都将导致出错。 管道是
详解：管道的读写规则以及原子性问题
初闻
08-13 2680
当管道空的时候 O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来为止（默认） O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN 【示例】： #include <stdio.h> ...
Pipe(管道)的一些理解
readlnh的博客
10-26 5709
Pipe(管道)的一些理解 管道的概念 管道是操作系统中常见的一种进程间通信方式，它使用于所有POSIX系统以及Windows系列产品。 管道也是unix ipc的最老形式，管道有两种限制： 数据自己读不能自己写 它们是半双工的。数据只能在一个方向上流动。 数据一旦被读走，便不在管道中存在，不可反复读取。 它们只能在具有公共祖先的进程之间使用。通常,一个管道由一个进程创建,然后该进程调用fork...
多线程/多进程写FIFO为原子操作(一次写小于PIPE_BUF内容)
lotus302的专栏
08-17 2346
#include #include #include #include #include #include #include #include #define WRITENUM 4 typedef struct writeattr writeattr; struct writeattr{ int id; int
管道的原子性问题
chirrupy_hamal的博客
10-28 748
管道(匿名/命名管道)的写数据大小在不超过PIPE_BUF(65536字节)时，内核能保证操作的原子性。如果写入的数据大小超过PIPI_BUF，内核很有可能会把此数据与其它进程的对此管道的写操作交替起来，这样的话，数据就乱了。 POSIX规定，小于PIPE_BUF的写操作必须是原子操作：要写的数据应该被连续地写到管道；大于PIPE_BUF的写操作可能是非原子的：内核可能会将数据与其他进程写入的数据...
linux系统编程之管道（二）：管道读写规则和Pipe Capacity、PIPE_BUF
Meditation
05-21 9340
一、当没有数据可读时 O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。 O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。 示例程序如下：  C++ Code  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 1
管道（二）——管道读写规则、管道容量Pipe Capacity、原子性PIPE_BUF——linux系统编程
z5z5z5z56的博客
07-31 1435
文章目录4种情况下的管道读写规则当没有数据可读（若父进程不写而子进程读）当管道满（若父进程写而子进程不读）管道容量Pipe Capacity若（父进程）写端突然关闭若（子进程）读端突然关闭linux写入原子性问题 本人的《APUE》《UNPv12》到啦！希望博文质量能有所提高！ 4种情况下的管道读写规则 我们用代码简单试验在一般情况下（O_NONBLOCK disable，默认阻塞）的4种情况： 1.当没有数据可读 2.当管道满的时候 3.所有管道读端对应的文件描述符被关闭 4.写端对应的文件描述符被关闭
【Linux】进程间通信
weixin_43550839的博客
02-06 118
一.进程间通信简介 1.进程间通信目的 数据传输：一个进程需要将它的数据发送给另一个进程 资源共享：多个进程之间共享同样的资源。 通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止 时要通知父进程）。 进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另 一个进程的所有陷入和异常，并能够及时知道它的状态改变。 2...
UNIX环境高级编程——管道读写规则和pipe Capacity、PIPE_BUF
weixin_33991727的博客
07-07 115
一、当没有数据可读时O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。示例程序如下：#include<sys/types.h> #include<sys/stat.h> #include<unistd.h> #include&l...
找bug#include "sys/types.h" #include "sys/file.h" #include "unistd.h" char r_buf[4]; //读缓冲 char w_buf[4]; //写缓冲 int pipe_fd[2]; pid_t pid1, pid2, pid3, pid4; int producer(int id); int consumer(int id); int main(int argc,char **argv) { if(pipe(pipe_fd)<0) { printf("pipe create error \n"); exit(-1); } else { printf("pipe is created successfully!\n"); if((pid1=fork())==0) producer(1); if((pid2=fork())==0) producer(2); if((pid3=fork())==0) consumer(1); if((pid4=fork())==0) consumer(2); } close(pipe_fd[0]); //需要加上这两句 close(pipe_fd[1]); //否这会有读者或者写者永远等待 int i,pid,status; for(i=0;i<4;i++) pid=wait(&status); exit(0); } int producer(int id) { printf("producer %d is running!\n",id); close(pipe_fd[0]); int i=0; for(i=1;i<10;i++) { sleep(3); if(id==1) //生产者1 strcpy(w_buf,"aaa\0"); else //生产者2 strcpy(w_buf,"bbb\0"); if(write(pipe_fd[1],w_buf,4)==-1) printf("write to pipe error\n"); } close(pipe_fd[1]); printf("producer %d is over!\n",id); exit(id); } int consumer(int id) { close(pipe_fd[1]); printf("producer %d is running!\n",id); if (id==1) //消费者1 strcpy(w_buf,"ccc\0"); else //消费者2 strcpy(w_buf,"ddd\0"); while(1) { sleep(1); strcpy(r_buf,"eee\0"); if(read(pipe_fd[0],r_buf,4)==0) break; printf("consumer %d get %s, while the w_buf is %s\n",id,r_buf,w_buf); } close(pipe_fd[0]); printf("consumer %d is over!\n", id); exit(id); }
最新发布
05-24
这段代码存在以下问题： 1. 在生产者函数中，每次写入数据时，写入的是一个字符串，但缓冲区只有4个字节大小，会导致溢出。 2. 在消费者函数中，每次读取数据时，读取的是4个字节大小的缓冲区，但实际上写入的数据可能小于4个字节，导致读取到的数据不正确。 3. 在主函数中，等待子进程退出的循环条件不正确，应该循环4次而不是循环3次。 4. 在主函数中，需要关闭管道的读端和写端，否则会有某个进程永远等待。 修改后的代码如下： ``` #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> char r_buf[1024]; // 读缓冲 char w_buf[1024]; // 写缓冲 int pipe_fd[2]; pid_t pid1, pid2, pid3, pid4; int producer(int id); int consumer(int id); int main(int argc, char **argv) { if (pipe(pipe_fd) < 0) { printf("pipe create error\n"); exit(-1); } else { printf("pipe is created successfully!\n"); if ((pid1 = fork()) == 0) producer(1); if ((pid2 = fork()) == 0) producer(2); if ((pid3 = fork()) == 0) consumer(1); if ((pid4 = fork()) == 0) consumer(2); } close(pipe_fd[0]); close(pipe_fd[1]); int i, pid, status; for (i = 0; i < 4; i++) pid = wait(&status); exit(0); } int producer(int id) { printf("producer %d is running!\n", id); close(pipe_fd[0]); int i = 0; for (i = 1; i < 10; i++) { sleep(3); if (id == 1) // 生产者1 strcpy(w_buf, "aaa"); else // 生产者2 strcpy(w_buf, "bbb"); if (write(pipe_fd[1], w_buf, strlen(w_buf) + 1) == -1) printf("write to pipe error\n"); } close(pipe_fd[1]); printf("producer %d is over!\n", id); exit(id); } int consumer(int id) { close(pipe_fd[1]); printf("consumer %d is running!\n", id); if (id == 1) // 消费者1 strcpy(w_buf, "ccc"); else // 消费者2 strcpy(w_buf, "ddd"); while (1) { sleep(1); memset(r_buf, 0, sizeof(r_buf)); int n = read(pipe_fd[0], r_buf, sizeof(r_buf)); if (n <= 0) break; printf("consumer %d get %s, while the w_buf is %s\n", id, r_buf, w_buf); } close(pipe_fd[0]); printf("consumer %d is over!\n", id); exit(id); } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值