shell read 命令除可以从标准输入流中读取字符串给变量外，还能从特定的文件中向变量赋值文件中的“一行内容”。每次给变量赋值为管道内容的输入的行内容。
1.例：read_file.sh

图1.read_file.sh读取文件内容
【3】对CountNum赋初始值为1.
【5-10】用cat命令打开for_read.c(在shell界面直接使用这个命令时，for_read.c的所有内容将会直接被展现在屏幕上)，通过管道 '|' 把for_read.c当前行的内容赋值给read命令后的变量line。打印行号和此行的内容，行号增加。如此循环，直到文件读取完毕，此时read命令返回值不为0.
【8-10】这是变量增1的两种表达方式。注意第十行的增1方式，前面的冒号":"不可省。
 
2.for_read.sh中的内容：

图2.for_read.c文件中的内容
3.运行脚本观看结果
首先，修改脚本权限：chmod +x  read_file.sh
运行脚本：./read_file.sh
运行结果为：

图3.read_file.sh脚本运行结果
4.总结
前辈们写的工具都是考虑的全面，从最简单的功能设计开始，都是会涉及到有可能且合理的功能上面去的。

How do I read a FIFO/named pipe line by line from a C++/Qt Linux app?
Today I can open and read from a fifo from a Qt program,
but I can't get the program to read the data line by line.
Qt reads the entire file, meaning he waits until the "sender" closes his session.
Let's take a example with some shell commands to show what I would like the app to do.
First create a fifo
mkfifo MyPipe
Then we can use cat to read from the fifo
cat MyPipe
And then we send some data in with another cat
cat > MyPipe
And then start to type something, and every time you hit enter it arrives at the reader.
And then when you close it with Ctrl+D both sides end.
Now the sender is easy to create with a QTextStream,
you just need to flush when you want to send.
QFile file("MyPipe");
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
return;
QTextStream out(&file);
for(int i=0; i<3; i++) {
out << "Hello...: " << i << "\n";
out.flush();
sleep(2);
}
file.close();
But then to write a little reader that read line by line is where I'm stuck right now,
all my tries with the Qt lib ends up with that I get the data but
not until the sender uses file.close() on the fifo.
Not when he flush, as occurs when I use cat to read.
Like this example:
QFile file("MyPipe");
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return 0;
QTextStream in(&file);
QString line;
do {
line = in.readLine();
qDebug() << line;
} while (!in.atEnd());
file.close();
What am I missing?
It just feels like I need to use some kind of isReady or lineAvailable on
the stream or something like that,
but I can't find anything in the docs that fits...
/Thanks
Note:
If I go with the low level c style and read one char at the time I do
get the style Im searching for.
But it would be nice to be able to do the same Qt style.
FILE *fp;
fp=fopen("MyPipe", "r");
char c;
while((c=getc(fp)) != EOF)
{
printf("%c",c);
}
fclose(fp);
Update:
When I start a debugger the program is hanging on the readLine(),
and do not continue until the other party closes the fifo.
And I do get the same using ">>"
line = in.readLine();
in >> line;
解决方案
Use the low level c style and read one char at the time.
FILE *fp;
fp=fopen("MyPipe", "r");
char c;
while((c=getc(fp)) != EOF)
{
printf("%c",c);
}
fclose(fp);

linux socket read 阻塞


read函数只是一个通用的读文件设备的接口。是否阻塞需要由设备的属性和设定所决定。一般来说，读字符终端、网络的socket描述字，管道文件等，这些文件的缺省read都是阻塞的方式。如果是读磁盘上的文件，一般不会是阻塞方式的。但使用锁和fcntl设置取消文件O_NOBLOCK状态，也会产生阻塞的read效果。
怎么样以非阻塞的方式从管道中读取数据？因为我用read函数时，如果管道没有数据就会阻塞住？？？


我的代码是: 
char chBuff[32]; 
read(file_pipe[0], chBuff, 16); 


如果管道没有数据我这个函数就永远不返回，请问有没有其它的方式，如果管道有数据就读取，没数据也立即返回？？  
或者在open的时候，传入O_NONBLOCK参数，按非阻塞方式打开 / fcntl(fd, F_SETFL, O_NONBLOCK)
在mode设置O_NONBLOCK标志
每一个TCP套接口有一个发送缓冲区，可以用SO_SNDBUF套接口选项来改变这个缓冲区的大小。当应用进程调用 write时，内核从应用进程的缓冲区中拷贝所有数据到套接口的发送缓冲区。如果套接口的发送缓冲区容不下应用程序的所有数据(或是应用进程的缓冲区大于套接口发送缓冲区，或是套接口发送缓冲区还有其他数据)，应用进程将被挂起(睡眠)。这里假设套接口是阻塞的，这是通常的缺省设置。内核将不从write系统调用返回，直到应用进程缓冲区中的所有数据都拷贝到套接口发送缓冲区。因此从写一个TCP套接口的write调用成功返回仅仅表示我们可以重新使用应用进程的缓冲区。它并不告诉我们对端的
 TCP或应用进程已经接收了数据。 
    TCP取套接口发送缓冲区的数据并把它发送给对端TCP，其过程基于TCP数据传输的所有规则。对端TCP必须确认收到的数据，只有收到对端的ACK，本端TCP才能删除套接口发送缓冲区中已经确认的数据。TCP必须保留数据拷贝直到对端确认为止。
1 输入操作: read、readv、recv、recvfrom、recvmsg
    如果某个进程对一个阻塞的TCP套接口调用这些输入函数之一，而且该套接口的接收缓冲区中没有数据可读，该进程将被投入睡眠，直到到达一些数据。既然 TCP是字节流协议，该进程的唤醒就是只要到达一些数据：这些数据既可能是单个字节，也可以是一个完整的TCP分节中的数据。如果想等到某个固定数目的数据可读为止，可以调用readn函数，或者指定MSG_WAITALL标志。
    既然UDP是数据报协议，如果一个阻塞的UDP套接口的接收缓冲区为空，对它调用输入函数的进程将被投入睡眠，直到到达一个UDP数据报。
    对于非阻塞的套接口，如果输入操作不能被满足（对于TCP套接口即至少有一个字节的数据可读，对于UDP套接口即有一个完整的数据报可读），相应调用将立即返回一个EWOULDBLOCK错误。
2 输出操作：write、writev、send、sendto、sendmsg
    对于一个TCP套接口，内核将从应用进程的缓冲区到该套接口的发送缓冲区拷贝数据。对于阻塞的套接口，如果其发送缓冲区中没有空间，进程将被投入睡眠，直到有空间为止。
    对于一个非阻塞的TCP套接口，如果其发送缓冲区中根本没有空间，输出函数调用将立即返回一个EWOULDBLOCK错误。如果其发送缓冲区中有一些空间，返回值将是内核能够拷贝到该缓冲区中的字节数。这个字节数也称为不足计数(short count)
    UDP套接口不才能在真正的发送缓冲区。内核只是拷贝应用进程数据并把它沿协议栈向下传送，渐次冠以UDP头部和IP头部。因此对一个阻塞的UDP套接口，输出函数调用将不会因为与TCP套接口一样的原因而阻塞，不过有可能会因其他的原因而阻塞

一、什么是管道
管道是从unux继承过来的最早的IPC通讯方式之一，它有如下特点：

管道数据的读写是半双工的，即只能从写端写入，从读端读出；
管道数据不能重复读取，一旦调用read读取写入管道的数据，这段数据将永久从管道中移除，不能被其它进程获取；
管道有点类似于队列，允许用户向其中连续放入多条内容，然后可以逐条取出；

二、有名管道和无名管道
2.1、无名管道

无名管道的存在依赖于创建它的进程，当进程退出后，无名管道的资源也会自动释放；
无名管道通信只能用于具有亲缘关系的进程之间的通讯（有名管道没有这个限制）；

2.2、有名管道

有名管道也叫FIFO，它在linux系统中作为一种特殊的文件而存在，并具有文件系统中的inode信息。
有名管道（FIFO）创建之后是独立存在的，它不依赖于创建它的进程，因此任何进程可以根据FIFO的名称来打开并进行读写操作；
读写FIFO的两个进程调用open打开同一个FIFO文件是会得到相同的文件描述符；
有名管道（FIFO）在创建之后如果不再使用，需要主动删除，否则它会一直存在于系统之中；
我们可以把FIFO简单理解成一个文件，只是FIFO不能用open或者create等普通文件的创建方式来创建，而需要用mkfifo函数来创建。使用mkfifo创建一个FIFO之后，我们就可以把FIFO当成普通文件来使用open打开，使用read和write进行读写。

四、管道相关函数
4.1、pipe函数
int pipe(int pipefd[2]);


pipe创建一个无名管道，pipfd用于指向管道两端的描述符。fppfd[0]指向读端，pipfd[1]指向管道的写端；
数据从管道写段写入，从管道读端读出，使用pipe创建得到的pipefd指向的是内存中的某一块内存，这块内存由系统分配，之后可以调用read和write对pipefd进行读写操作。

4.2、mkfifo函数
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);


mkfifo用来创建一个有名管道（FIFO），它的第一个参数指定一个路径名，mode指定FIFO的权限，如0666表示具有可读和可写权限。
mkfifo调用成功返回0，失败返回-1。

示例：
fifo_read.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>

int main()
{
	int ret = -1;
	char *path = "/myfifo";
	char buffer[1024];
	int fd = -1;
	
	if(0 != access(path,F_OK))//如果文件不存在，创建FIFO文件
	{
		ret = mkfifo(path,0666);
		if(0 != ret)
		{
			perror("mkfifo error\r\n");
			return -1;
		}
	}
	
	fd = open(path,O_RDONLY);
	if(0 > fd)
	{
		perror("open fifo error\r\n");
		return -1;
	}
	printf("read fifo fd:%d\r\n",fd);
	while(1)
	{
		memset(buffer,0,sizeof(buffer));
		if(read(fd,buffer,sizeof(buffer))<=0)
		{
			perror("read error");
			break;
		}
		printf("read fifo:%s",buffer);
		if(0 == strncmp(buffer,"exit",4))
		{
			break;
		}
	}
	printf("read process exit\r\n");
	close(fd);
}

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

int main()
{
	int ret = -1;
	char *path = "/myfifo";
	char buffer[1024];
	int fd = -1;
	
	if(0 != access(path,F_OK))//如果文件不存在，创建FIFO文件
	{
		ret = mkfifo(path,0666);
		if(0 != ret)
		{
			perror("mkfifo error\r\n");
			return -1;
		}
	}
	
	fd = open(path,O_WRONLY);
	if(0 > fd)
	{
		perror("open fifo error\r\n");
		return -1;
	}
	printf("write fifo fd:%d\r\n",fd);
	while(1)
	{
		printf("write some data:");
		ret = fgets(buffer,1024,stdin);
		if(write(fd,buffer,sizeof(buffer))<0)
		{
			perror("write error");
			break;
		}
		if(0 == strncmp(buffer,"exit",4))
		{
			break;
		}
	}
	printf("write process close fd\r\n");
	close(fd);
}

gcc fifo_write.c -o write
gcc fifo_read.c -o read

分别在两个shell中运行read和write，运行结果如下