管道使用举例

最新推荐文章于 2022-10-14 18:09:25 发布
最新推荐文章于 2022-10-14 18:09:25 发布
阅读量824 收藏 1
点赞数
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lanyang123456/article/details/40450173
版权

//----------------------------------------------------

//AUTHOR: lanyang123456

//DATE: 2014-10-26

//----------------------------------------------------





管道是一种两个进程间进行单向通信的机制。因为管道传递数据的单向性，管道又称为半双工管道。管道的这一特点决定了其使用的局限性。具有以下特点：

*** 数据只能由一个进程流向另一个进程（其中一个读管道，一个写管道）；如果要进行双工通信，需要建 立两个管道。
*** 管道只能用于父子进程或者兄弟进程间通信。，也就是说管道只能用于具有亲缘关系的进程间通信。






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

int
main(int argc, char *argv[])
{
	int pipefd[2];
	pid_t cpid;
	char buf;

	if (argc != 2) {
		fprintf(stderr, "Usage: %s <string>\n", argv[0]);
		exit(EXIT_FAILURE);
	}

	if (pipe(pipefd) == -1) {
               perror("pipe");
               exit(EXIT_FAILURE);
	}
	printf("before fork\n");

	cpid = fork();
	if (cpid == -1) {
               perror("fork");
               exit(EXIT_FAILURE);
	}
	
	if (cpid == 0) {    /* Child reads from pipe */
		close(pipefd[1]);          /* Close unused write end */
		printf("child get parent's:\n");
		while (read(pipefd[0], &buf, 1) > 0)
			write(STDOUT_FILENO, &buf, 1);

		write(STDOUT_FILENO, "\n", 1);
		close(pipefd[0]);
		printf("--------child exit-------\n");
		_exit(EXIT_SUCCESS);
		//exit(EXIT_SUCCESS);

	} else {            /* Parent writes argv[1] to pipe */
		close(pipefd[0]);          /* Close unused read end */
		printf("parent give child %s\n", argv[1]);
		write(pipefd[1], argv[1], strlen(argv[1]));
		close(pipefd[1]);          /* Reader will see EOF */
		wait(NULL);                /* Wait for child */
		printf("---------parent exit-------\n");
		exit(EXIT_SUCCESS);
	}
}

$ gcc -o test pipe1.c
$ ./test hello
before fork
parent give child hello
child get parent's:
hello
--------child exit-------
---------parent exit-------


有个地方值得关注一下，就是exit和_exit的区别：

exit() 做的工作包括：执行退出处理函数；关闭所有标准iO流（这会导致所有的缓冲数据都会被冲洗，即写到文件）;然后调用_exit();

如果这样执行程序，可看到区别。

$ ./test hello > tmp
$ cat tmp
hello
before fork
parent give child hello
---------parent exit-------






下面的代码通过管道实现重定向， 将标准输出定向到管道的写入端，标准输入定向到管道的读取端。







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


#define	MAXLEN	2048

int main()
{
	int pipefd[2];

	int ret = pipe(pipefd);
	if (ret < 0) {
		perror("pipe");
               	exit(EXIT_FAILURE);	
	}

	int pid = fork();
	if (pid < 0) {
		perror("fork");
               	exit(EXIT_FAILURE);
	} else if (pid == 0) {//child
		close(pipefd[0]);   //关闭不需要的端
	
		if (pipefd[1] != STDOUT_FILENO) { //重定向管道输出端到标准输出
			if (dup2(pipefd[1], STDOUT_FILENO) != STDOUT_FILENO) {
				perror("dup2");
               			exit(EXIT_FAILURE);
			}
			close(pipefd[1]);
		}
		
		//write(STDOUT_FILENO, "one ", strlen("one "));
		execlp("ls", "ls", "-l", (char *)0); //由于将stdout重定向为管道的输入端,所以这行的执行结果被存放在管道输入端
		_exit(127);
	} else if(pid > 0) {//parent
		close(pipefd[1]);
		char buffer[MAXLEN];
		char ret;
		int nread = 0;
		memset(buffer, 0, MAXLEN);
		if (pipefd[0] != STDIN_FILENO) { //重定向管道读端到标准输入
			if (dup2(pipefd[0], STDIN_FILENO) != STDIN_FILENO) {
				perror("dup2");
               			exit(EXIT_FAILURE);
			}
			close(pipefd[0]);
		}
		
		/*do {
			ret = read(STDIN_FILENO, buffer + nread, MAXLEN - 1);
			if (ret < 0 && errno == EINTR) {
				continue;			
			} else if (ret > 0) {
				nread += ret;
			}		
		}
		while ( ret > 0);
		
		printf("%s", buffer);
		fflush(stdout);*/
		execlp("wc", "wc", "-l", (char *)0);  //这里wc后面没有给出文件名,所以从标准输入读取,而标准输入端被定向为管道输出端
		//，所以读取的数据即为上面ls -l的执行结果
	} else {
		printf("fork error/n");
	}

	return 0;
}

 $./test2
17

17行


再举一例：





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


#define	MAXLEN	2048

int main()
{
	int pipefd[2];

	int ret = pipe(pipefd);
	if (ret < 0) {
		perror("pipe");
               	exit(EXIT_FAILURE);	
	}

	int pid = fork();
	if (pid < 0) {
		perror("fork");
               	exit(EXIT_FAILURE);
	} else if (pid == 0) {//child
		close(pipefd[0]);   //关闭不需要的端
	
		if (pipefd[1] != STDOUT_FILENO) { //重定向管道输出端到标准输出
			if (dup2(pipefd[1], STDOUT_FILENO) != STDOUT_FILENO) {
				perror("dup2");
               			exit(EXIT_FAILURE);
			}
			close(pipefd[1]);
		}
		
		printf("child write to pipe.\n");//现在向标准输出写入，即是向管道写入
		printf("child write to pipe.\n");
		fflush(stdout);//必须的，若无，上面的写到管道的字符串不会立即发送到管道
		write(STDOUT_FILENO, "one ", strlen("one "));
		execlp("ls", "ls", "-l", (char *)0); //由于将stdout重定向为管道的输入端,所以这行的执行结果被存放在管道输入端
		_exit(127);
	
	} else if(pid > 0) {//parent
		close(pipefd[1]);
		char buffer[MAXLEN];
		int ret;
		int nread = 0;	
		
		memset(buffer, 0, MAXLEN);
		do {
			ret = read(pipefd[0], buffer + nread, MAXLEN - 1);
			if (ret < 0 && errno == EINTR) {
				continue;			
			} else if (ret > 0) {
				nread += ret;
			}		
		}
		while ( ret > 0);

		printf("parent output: %s", buffer);
		printf("\n");

		//execlp("wc", "wc", "-l", (char *)0);  //这里wc后面没有给出文件名,所以从标准输入读取,而标准输入端被定向为管道输出端
		//，所以读取的数据即为上面ls -l的执行结果
	} else {
		printf("fork error/n");
	}

	return 0;
}

$ gcc -o test2.1 pipe2.1.c
$ ./test2.1
parent output: child write to pipe.
child write to pipe.
one total 88
-rwxrwxr-x 1 lanyang lanyang 7671 10月 26 21:01 fifo
-rw-rw-r-- 1 lanyang lanyang 1341 10月 26 21:02 fifo.c
-rw-rw-r-- 1 lanyang lanyang 1209 10月 26 21:01 fifo.c~
-rw-rw-r-- 1 lanyang lanyang 1498 10月 25 16:46 notes
-rw-rw-r-- 1 lanyang lanyang 1503 10月 25 10:06 notes~
-rw-rw-r-- 1 lanyang lanyang 1194 10月 26 16:33 pipe1.1.c
-rw-rw-r-- 1 lanyang lanyang 1194 10月 26 16:32 pipe1.1.c~
-rw-rw-r-- 1 lanyang lanyang 1410 10月 26 15:26 pipe1.c
-rw-rw-r-- 1 lanyang lanyang 1426 10月 26 15:22 pipe1.c~
-rw-rw-r-- 1 lanyang lanyang 1751 10月 26 16:49 pipe2.1.c
-rw-rw-r-- 1 lanyang lanyang 1758 10月 26 21:25 pipe2.c
-rw-rw-r-- 1 lanyang lanyang 1738 10月 26 17:23 pipe2.c~
-rwxrwxr-x 1 lanyang lanyang 7770 10月 25 15:30 test
-rwxrwxr-x 1 lanyang lanyang 7623 10月 26 16:33 test1.1
-rwxrwxr-x 1 lanyang lanyang 7674 10月 26 17:23 test2
-rwxrwxr-x 1 lanyang lanyang 7944 10月 26 21:29 test2.1

-rw-rw-r-- 1 lanyang lanyang   70 10月 26 21:21 tmp


若程序改为：

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


#define	MAXLEN	2048

int main()
{
	int pipefd[2];

	int ret = pipe(pipefd);
	if (ret < 0) {
		perror("pipe");
               	exit(EXIT_FAILURE);	
	}

	int pid = fork();
	if (pid < 0) {
		perror("fork");
               	exit(EXIT_FAILURE);
	} else if (pid == 0) {//child
		close(pipefd[0]);   //关闭不需要的端
	
		if (pipefd[1] != STDOUT_FILENO) { //重定向管道输出端到标准输出
			if (dup2(pipefd[1], STDOUT_FILENO) != STDOUT_FILENO) {
				perror("dup2");
               			exit(EXIT_FAILURE);
			}
			close(pipefd[1]);
		}
		
		printf("child write to pipe.\n");//现在向标准输出写入，即是向管道写入
		printf("child write to pipe.\n");
		//fflush(stdout);//必须的，若无，上面的写到管道的字符串不会立即发送到管道
		//write(STDOUT_FILENO, "one ", strlen("one "));
		execlp("ls", "ls", "-l", (char *)0); //由于将stdout重定向为管道的输入端,所以这行的执行结果被存放在管道输入端
		_exit(127);
	
	} else if(pid > 0) {//parent
		close(pipefd[1]);
		char buffer[MAXLEN];
		int ret;
		int nread = 0;	
		
		memset(buffer, 0, MAXLEN);
		do {
			ret = read(pipefd[0], buffer + nread, MAXLEN - 1);
			if (ret < 0 && errno == EINTR) {
				continue;			
			} else if (ret > 0) {
				nread += ret;
			}		
		}
		while ( ret > 0);

		printf("parent output: %s", buffer);
		printf("\n");

		//execlp("wc", "wc", "-l", (char *)0);  //这里wc后面没有给出文件名,所以从标准输入读取,而标准输入端被定向为管道输出端
		//，所以读取的数据即为上面ls -l的执行结果
	} else {
		printf("fork error/n");
	}

	return 0;
}


$ gcc -o test2.1 pipe2.1.c
lanyang@lanyang-ThinkPad-Edge-E431:~/exercise/pipe$ ./test2.1
parent output: total 92
-rwxrwxr-x 1 lanyang lanyang 7671 10月 26 21:01 fifo
-rw-rw-r-- 1 lanyang lanyangn 1341 10月 26 21:02 fifo.c
-rw-rw-r-- 1 lanyang lanyang 1209 10月 26 21:01 fifo.c~
-rw-rw-r-- 1 lanyang lanyang 1498 10月 25 16:46 notes
-rw-rw-r-- 1 lanyang lanyang 1503 10月 25 10:06 notes~
-rw-rw-r-- 1 lanyang lanyang 1194 10月 26 16:33 pipe1.1.c
-rw-rw-r-- 1 lanyang lanyang 1194 10月 26 16:32 pipe1.1.c~
-rw-rw-r-- 1 lanyang lanyang 1410 10月 26 15:26 pipe1.c
-rw-rw-r-- 1 lanyang lanyang 1426 10月 26 15:22 pipe1.c~
-rw-rw-r-- 1 lanyang lanyang 2838 10月 26 21:31 pipe2.1.c
-rw-rw-r-- 1 lanyang lanyang 2836 10月 26 21:31 pipe2.1.c~
-rw-rw-r-- 1 lanyang lanyang 1758 10月 26 21:25 pipe2.c
-rw-rw-r-- 1 lanyang lanyang 1738 10月 26 17:23 pipe2.c~
-rwxrwxr-x 1 lanyang lanyang 7770 10月 25 15:30 test
-rwxrwxr-x 1 lanyang lanyang 7623 10月 26 16:33 test1.1
-rwxrwxr-x 1 lanyang lanyang 7674 10月 26 17:23 test2
-rwxrwxr-x 1 lanyang lanyang 7835 10月 26 21:32 test2.1
-rw-rw-r-- 1 lanyang lanyang   70 10月 26 21:21 tmp


会发现使用printf写到管道中的数据丢失了。这是因为printf带有缓冲区，标准输入重定向为管道写断后，变为全缓冲。printf的数据不会立刻放到管道中。

后面再执行exec,输出的数据会将前面的数据覆盖，于是管道中就不会有printf的数据了。这个地方如果使用write则会正常，因为write不带缓冲，直接写到管道中。如果带缓冲区的printf，则fflush一下。



命名管道：



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

#define FNAME "/tmp/TestFIFO"

int main()
{
   char buffer[32] = {0};

   //注意下面的0666
   //4 2 1分别表示读、写和执行权限
   //第一个6表示文件所有者具有读写权限
   //第二个6表示同组用户权限
   //地三个6表示其他用户读写权限

   int mkRet = mkfifo(FNAME, 0666); //mkfifo的第一个参数必须是不存在的文件,执行第二次就会出错

   if (mkRet == -1)
   {
       perror("mkfifo failed\n");
       exit(1);
   }
   int pid = fork();
   if (pid < 0) {
	perror("fork error");
	exit(1);
   }
   else if (pid == 0) //子进程
   {
      int fd = open(FNAME, O_RDONLY);
      read(fd, buffer, sizeof(buffer));  //read会一直等待可读数据
      printf("r content = %s\n", buffer);
      close(fd);
   }
   else if (pid > 0)
   {
     // wait(NULL);
      char s[] = "what a nice day!";
      int fd = open(FNAME, O_WRONLY);
      size_t len = sizeof(s);
      printf("len = %d\n", len);
      write(fd, s, sizeof(s));
      printf("write over!\n");
      close(fd);
   }

   return 0;
}

$ gcc -o fifo fifo.c
$ ./fifo
len = 17
write over!
r content = what a nice day!

第二次执行，则会出错。
$ ./fifo
mkfifo failed
: File exists



参考

http://blog.csdn.net/wutaozhao/article/details/6010665

http://blog.csdn.net/ljianhui/article/details/10202699



翔云123456
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
匿名管道与命名管道的使用
05-23
管道分类： 根据进程的相互关系，可以分为：匿名管道与命名管道。 1 匿名管道：管道是父进程和子进程间，或是子进程与子进程间单向的通讯机制，即一个进程发送数据到管道，另外一个进程从管道中读出数据。如果需要...
举例讲解Java中Piped管道输入输出流的线程通信控制
09-02
Java中的PipedWriter、PipedReader类管道的读写依赖于PipedOutputStream、PipedInputStream两个管道输入输出类,这里我们将来举例讲解Java中Piped管道输入输出流的线程通信控制:
Springboot 使用管道设计模式 , 实践案例玩一玩
默默不代表沉默
10-14 5596
Springboot 使用管道设计模式 , 实践案例玩一玩
进程通信的实例－－管道(pipe)
thinkinwm的专栏
03-23 1万+
4.7.5 进程通信的实例－－管道(pipe) 1.管道pipe     进程通信的使用例子之一是UNIX系统的管道通信。UNIX系统从System V 开始，提供有名管道和无名管道两种通信方式，这里介绍无名管道。 无名管道为建立管道的进程及其子孙提供一条以比特流方式传送消息的通信管道。该管道再逻辑上被看作管道文件，在物理上则由文件系统的高速缓冲区构成，而很少启动外设。发送进程利用文件系统
linux管道举例理解
宝藏女孩的成长日记
05-07 4820
linux管道举例理解一、管道的定义：“|”二、查找2.1统计当前目录下有多少个文件2.2查看当前目录下的前n（3）个文件2.3查看wang.txt文件包含i的字符行2.4查看内存使用情况2.5查询进程三、更改 一、管道的定义：“|” 一般我们在进行操作的时候，命令很多，但我们只想要其中一部分，那么就可以使用管道了。 管道是Linux中很重要的一种通信方式,是把一个前一个结果的输出直接连接到另一个...
解决：未能将管道连接到虚拟机: 所有的管道范例都在使用中。
热门推荐
Allen . Liu
08-22 5万+
虚拟机无端出现: VMwareWorkstation无法连接到虚拟机。请确保您有权限运行该程序、访问改程序使用的所有目录以及访问所有临时文件目录。未能将管道连接到虚拟机: 所有的管道范例都在使用中。 原因：Ubuntu开机慢到开不开，我就在任务管理器强制结束了进程，再次打开出现了这个问题 思考：杀掉进程的时候可能有些相关进程没有关掉，导致管道未释放 解决办法：打开任务管理器，杀掉VMw...
管道的三种使用方案中，唯一正确而安全的使用方法
jia12216的专栏
03-24 1909
系统自带的管道方法： 全局变量： NSPipe * pipe = [NSPipe pipe] ; NSFileHandle *pipeReadHandle = [pipe fileHandleForReading] ； int pipeReadFd = [[pipe fileHandleForReading] fileDescriptor], fd]; int pipeWriteF
管道流PipedStream应用举例
05-14
针对java中的管道流的应用的解析，包括PipedInputStream和PipedOutputStream。
通信管道工作量计算
12-29
以包封高190mm，宽380mm外径φ110的2孔双壁波纹管100m举例： 外径φ110的2孔双壁波纹管，管孔半径为55mm，根据圆的面积计算公式 1孔双壁波纹管面积=3.14×（55mm）2=0.0094985m2≈0.0095m2 2孔双壁波纹管面积=0....
linux sed 常用用法举例01
04-13
- `sed`可以与其他命令结合使用，通过管道`|`传递数据。 示例： ```bash grep 'pattern' file.txt | sed 's/Linux/Unix/g' ``` 先使用`grep`找出包含“pattern”的行，再用`sed`替换其中的“Linux”。 8. **...
linux管道应用实例,[Linux管道和IPC]管道的实际应用1
weixin_32659841的博客
05-13 236
/*主进程创建2个子进程，子进程1每隔1秒向子进程2发送一个字符串，子进程接收到该字符串之后将其写入一个指定的文件*/#include#include#include#include#include#include#include#include//以下为主函数intmain(intargc,char*argv[]){pid_tpid1,pid2;/...
Linux 管道的用法
a1534219218的博客
06-04 5092
说明： Linux的管道用于进程间的通信，进程通过PIPE函数，在内核中创建管道，而管道是一个单向队列。 PIPE函数注意： 1. 管道是创建在内存中的，进程结束，空间释放，管道就不存在了 2. 管道中的动心，读完了就删除了，是一个单向队列 3. 如果管道中没有东西可读，会读阻塞 4. 当我们写的内容超过管道的空间时，会产生写阻塞 5. 写管道是fd[1]，读管道是fd[0] ...
C++有名管道通信简单示例
MusicMan
01-03 1614
有名管道，简单的理解可以理解成，一个通过命名不同来实现通信的一种方式。 简单的有名管道实现逻辑如下： * 1. CreateNamedPipe 创建一个有名管道，在系统中 * 2。::ConnectNamedPipe 监听客户端的连接，获取数据 作为客户端而言 1.::WaitNamedPipe(PIPE_CLIENT_NAME, NMPWAIT_WAIT_FOREVER)// 连接到有名管...
shell脚本--管道的使用实例
菜鸟博客
04-21 1万+
管道经常用于拼接命令，通过管道可以执行一些复杂的数据处理操作。以下为在shell中使用管道处理数据的的几个实例示例1：生成一个8位的随机密码tr -dc A-Za-z0-9_ &lt;/dev/urandom  | head -c 8 | xargs示例2：查看系统中所有的用户名称，并按字母排序awk -F: '{print $1}'  /etc/passwd | sort示例3：列出当前用户使用...
利用管道实现控制台程序输入输出的重定向
长弓落日的专栏
06-29 1984
<br />在vc++6.0 创建控制台程序，编译测试通过。支持UniCode<br />控制台测试程序（and.exe）<br />#include "stdafx.h"<br />#include "stdio.h"<br />int main(int argc, char* argv[])<br />{<br /> int x,y;<br />// while(1)<br /> {<br /> printf("Input First Num:/r/n");<br /> scanf( "%d", &x
linux管道的原理和使用方法
qq_36761506的博客
06-20 295
链接地址：https://www.cnblogs.com/sallyliu/p/6385806.html
Linux IPC实践(2) --匿名PIPE
菜鸟-翡青
02-18 1667
管道概念   管道是Unix中最古老的进程间通信的形式,我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”, 管道的本质是固定大小的内核缓冲区;   如:ps aux | grep httpd | awk '{print $2}' 管道限制   1)管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道;   2)匿名管道只能用于具有共同祖先的进程(如父进程与fork
进程间通信系列（一）管道读写实例
YEYUANGEN的专栏
08-31 7889
一、管道读写注意点 1.只有在管道读端存在时，向管道写入才有意义；否则，会收到内核中的出错信号：SIFPIPE 2.向管道写入数据时不保证写入的原子性，管道缓冲区一有空闲区域，写进程就试图向其写入内容。若读进程不读取管道中的内容，则写进程会一直阻塞。 3.父子进程在运行时，
管道的使用
小猪观察员的博客
05-02 344
使用服务器拥有一个管道，用于从客户端接受消息，发送需要服务器转发的消息以及下线通知。服务器需要维护一个列表（使用结构体），记录哪些用户已经连上服务器用于接受消息的管道。当客户端启动，会向服务器发送上线消息，同时将自己的PID发送给server,server会将其添加到列表，以后会转发消息给在列表上的客户端。与此同时，客户端需要创建一个管道，用于接受服务器转发的消息；注意，要将其创建的管道名称告知服务器，一边server打开管道写端，告知管道名称可以在客户端向server发送线上消息时一并发送。当客户端下..
linux xargs的使用举例
最新发布
02-06
首先，我们可以使用find命令找到所有的.txt文件，并将结果通过管道传递给xargs命令： ``` find . -name "*.txt" | xargs wc -l ``` 上述命令中，`find . -name "*.txt"`会找到当前目录及其子目录下所有以.txt结尾...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值