linux 管道文件上机总结,[转载]LINUX 管道 fifo 等总结
Linux进程通信:命名管道FIFO小结
Linux下进程之间通信可以用命名管道FIFO完成。命名管道是一种特殊类型的文件,因为Linux中所有事物都是文件,它在文件系统中以文件名的形式存在。
在程序中,我们可以使用两个不同的函数调用来建立管道:
#include
#include
int mkfifo(const char *filename,
mode_t mode);
int mknode(const char *filename,
mode_t mode | S_IFIFO, (dev_t) 0 );
下面先来创建一个管道:
#include
#include
#include
#include
intmain()
{
intres = mkfifo("/tmp/my_fifo", 0777);
if(res == 0)
{
printf("FIFO created/n");
}
exit(EXIT_SUCCESS);
}
#include
#include
#include
#include
int main()
{
int res = mkfifo("/tmp/my_fifo", 0777);
if (res == 0)
{
printf("FIFO created/n");
}
exit(EXIT_SUCCESS);
}
编译这个程序:
gcc –o fifo1.c
fifo
运行这个程序:
$ ./fifo1
用ls命令查看所创建的管道
$ ls -lF
/tmp/my_fifo
prwxr-xr-x 1 root root 0 05-08
20:10 /tmp/my_fifo|
注意:ls命令的输出结果中的第一个字符为p,表示这是一个管道。最后的|符号是由ls命令的-F选项添加的,它也表示是这是一个管道。
虽然,我们所设置的文件创建模式为“0777”,但它被用户掩码(umask)设置(022)给改变了,这与普通文件创建是一样的,所以文件的最终模式为755。
打开FIFO一个主要的限制是,程序不能是O_RDWR模式打开FIFO文件进行读写操作,这样做的后果未明确定义。这个限制是有道理的,因为我们使用FIFO只是为了单身传递数据,所以没有必要使用O_RDWR模式。如果一个管道以读/写方式打开FIFO,进程就会从这个管道读回它自己的输出。如果确实需要在程序之间双向传递数据,最好使用一对FIFO,一个方向使用一个。
当一个Linux进程被阻塞时,它并不消耗CPU资源,这种进程的同步方式对CPU而言是非常有效率的。
有关Linux下命名管道FIFO的读写规则可以参见之前所写的一篇文章:。
一、实验:使用FIFO实现进程间通信
两个独立的程序:
1.
生产者程序,它在需要时创建管道,然后尽可能快地向管道中写入数据。
2.
消费者程序,它从FIFO中读取数据并丢弃它们。
生产者程序fifo2.c:
#include
#include
#include
#include
#include
#include
#include
#define FIFO_NAME "/tmp/Linux/my_fifo"
#define BUFFER_SIZE PIPE_BUF
#define TEN_MEG (1024 * 1024 * 10)
intmain()
{
intpipe_fd;
intres;
intopen_mode = O_WRONLY;
intbytes = 0;
charbuffer[BUFFER_SIZE + 1];
if(access(FIFO_NAME, F_OK) == -1)
{
res = mkfifo(FIFO_NAME, 0777);
if(res != 0)
{
fprintf(stderr, "Could not create fifo %s/n", FIFO_NAME);
exit(EXIT_FAILURE);
}
}
printf("Process %d opening FIFO O_WRONLY/n", getpid());
pipe_fd = open(FIFO_NAME, open_mode);
printf("Process %d result %d/n", getpid(), pipe_fd);
if(pipe_fd != -1)
{
while(bytes
{
res = write(pipe_fd, buffer, BUFFER_SIZE);
if(res == -1)
{
fprintf(stderr, "Write error on pipe/n");
exit(EXIT_FAILURE);
}
bytes += res;
}
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}
printf("Process %d finish/n", getpid());
exit(EXIT_SUCCESS);
}
#include
#include
#include
#include
#include
#include
#include
#define FIFO_NAME "/tmp/Linux/my_fifo"
#define BUFFER_SIZE PIPE_BUF
#define TEN_MEG (1024 * 1024 * 10)
int main()
{
int pipe_fd;
int res;
int open_mode = O_WRONLY;
int bytes = 0;
char buffer[BUFFER_SIZE + 1];
if (access(FIFO_NAME, F_OK) == -1)
{
res = mkfifo(FIFO_NAME, 0777);
if (res != 0)
{
fprintf(stderr, "Could not create fifo %s/n", FIFO_NAME);
exit(EXIT_FAILURE);
}
}
printf("Process %d opening FIFO O_WRONLY/n", getpid());
pipe_fd = open(FIFO_NAME, open_mode);
printf("Process %d result %d/n", getpid(), pipe_fd);
if (pipe_fd != -1)
{
while (bytes < TEN_MEG)
{
res = write(pipe_fd, buffer, BUFFER_SIZE);
if (res == -1)
{
fprintf(stderr, "Write error on pipe/n");
exit(EXIT_FAILURE);
}
bytes += res;
}
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}
printf("Process %d finish/n", getpid());
exit(EXIT_SUCCESS);
}
消费者程序fifo3.c:
#include
#include
#include
#include
#include
#include
#include
#define FIFO_NAME "/tmp/Linux/my_fifo"
#define BUFFER_SIZE PIPE_BUF
intmain()
{
intpipe_fd;
intres;
intopen_mode = O_RDONLY;
charbuffer[BUFFER_SIZE + 1];
intbytes = 0;
memset(buffer, '/0',sizeof(buffer));
printf("Process %d opeining FIFO O_RDONLY/n", getpid());
pipe_fd = open(FIFO_NAME, open_mode);
printf("Process %d result %d/n", getpid(), pipe_fd);
if(pipe_fd != -1)
{
do{
res = read(pipe_fd, buffer, BUFFER_SIZE);
bytes += res;
}while(res > 0);
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}
printf("Process %d finished, %d bytes read/n", getpid(), bytes);
exit(EXIT_SUCCESS);
}
#include
#include
#include
#include
#include
#include
#include
#define FIFO_NAME "/tmp/Linux/my_fifo"
#define BUFFER_SIZE PIPE_BUF
int main()
{
int pipe_fd;
int res;
int open_mode = O_RDONLY;
char buffer[BUFFER_SIZE + 1];
int bytes = 0;
memset(buffer, '/0', sizeof(buffer));
printf("Process %d opeining FIFO O_RDONLY/n", getpid());
pipe_fd = open(FIFO_NAME, open_mode);
printf("Process %d result %d/n", getpid(), pipe_fd);
if (pipe_fd != -1)
{
do{
res = read(pipe_fd, buffer, BUFFER_SIZE);
bytes += res;
}while(res > 0);
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}
printf("Process %d finished, %d bytes read/n", getpid(), bytes);
exit(EXIT_SUCCESS);
}
编译这两个程序:
gcc –o fifo2
fifo2.c
gcc –o fifo3
fifo3.c
运行这两个程序:
[root@localhost chaper12]# ./fifo2
&
à后台执行,写数据
[2] 23121
Process 23121 opening FIFO
O_WRONLY
[root@localhost chaper12]# time
./fifo3à读数据
Process 24155 opeining FIFO
O_RDONLY
Process 23121 result
3
Process 24155 result
3
Process 23121
finish
Process 24155 finished, 10485760
bytes read
[2]- Done
./fifo2
real 0m0.214s
user 0m0.000s
sys 0m0.179s
以上两个程序均是使用阻塞模式FIFO。Linux会安排好这两个进程之间的调试,使它们在可以运行的时候运行,在不能运行的时候阻塞。因此,写进程将在管道满时阻塞,读进程将在管道空时阻塞。
虚拟机上,time命令显示,读进程只运行了0.2秒的时间,却读取了10M字节的数据。这说明管道在程序之间传递数据是非常有效的。
二、实验:使用FIFO的客户/服务器应用程序
利用FIFO实现一个客户/服务器的应用程序,服务器进程接受请求,对它们进程处理,最后把结果数据返回给发送请求的客户方。
首先建立一个头文件client.h,它定义了客户和服务器程序都要用到的数据结构,并包含了必要的头文件。
#include
#include
#include
#include
#include
#include
#include
#define SERVER_FIFO_NAME "/tmp/Linux/chaper12/server_fifo"
#define CLIENT_FIFO_NAME "/tmp/Linux/chaper12/client_%d_fifo"
#define BUFFER_SIZE PIPE_BUF
#define MESSAGE_SIZE 20
#define NAME_SIZE 256
typedefstructmessage
{
pid_t client_pid;
chardata[MESSAGE_SIZE + 1];
}message;
#include
#include
#include
#include
#include
#include
#include
#define SERVER_FIFO_NAME "/tmp/Linux/chaper12/server_fifo"
#define CLIENT_FIFO_NAME "/tmp/Linux/chaper12/client_%d_fifo"
#define BUFFER_SIZE PIPE_BUF
#define MESSAGE_SIZE 20
#define NAME_SIZE 256
typedef struct message
{
pid_t client_pid;
char data[MESSAGE_SIZE + 1];
}message;
接下来是服务器程序server.c,在这一部分,是以只读阻塞模式打开服务器管道,用于接收客户发送过来的数据,这些数据采用message结构体封装。
#include "client.h"
intmain()
{
intserver_fifo_fd;
intclient_fifo_fd;
intres;
charclient_fifo_name[NAME_SIZE];
message msg;
char*p;
if(mkfifo(SERVER_FIFO_NAME, 0777) == -1)
{
fprintf(stderr, "Sorry, create server fifo failure!/n");
exit(EXIT_FAILURE);
}
server_fifo_fd = open(SERVER_FIFO_NAME, O_RDONLY);
if(server_fifo_fd == -1)
{
fprintf(stderr, "Sorry, server fifo open failure!/n");
exit(EXIT_FAILURE);
}
sleep(5);
while(res = read(server_fifo_fd, &msg,sizeof(msg)) > 0)
{
p = msg.data;
while(*p)
{
*p = toupper(*p);
++p;
}
sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid);
client_fifo_fd = open(client_fifo_name, O_WRONLY);
if(client_fifo_fd == -1)
{
fprintf(stderr, "Sorry, client fifo open failure!/n");
exit(EXIT_FAILURE);
}
write(client_fifo_fd, &msg, sizeof(msg));
close(client_fifo_fd);
}
close(server_fifo_fd);
unlink(SERVER_FIFO_NAME);
exit(EXIT_SUCCESS);
}
#include "client.h"
int main()
{
int server_fifo_fd;
int client_fifo_fd;
int res;
char client_fifo_name[NAME_SIZE];
message msg;
char *p;
if (mkfifo(SERVER_FIFO_NAME, 0777) == -1)
{
fprintf(stderr, "Sorry, create server fifo failure!/n");
exit(EXIT_FAILURE);
}
server_fifo_fd = open(SERVER_FIFO_NAME, O_RDONLY);
if (server_fifo_fd == -1)
{
fprintf(stderr, "Sorry, server fifo open failure!/n");
exit(EXIT_FAILURE);
}
sleep(5);
while (res = read(server_fifo_fd, &msg, sizeof(msg)) > 0)
{
p = msg.data;
while (*p)
{
*p = toupper(*p);
++p;
}
sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid);
client_fifo_fd = open(client_fifo_name, O_WRONLY);
if (client_fifo_fd == -1)
{
fprintf(stderr, "Sorry, client fifo open failure!/n");
exit(EXIT_FAILURE);
}
write(client_fifo_fd, &msg, sizeof(msg));
close(client_fifo_fd);
}
close(server_fifo_fd);
unlink(SERVER_FIFO_NAME);
exit(EXIT_SUCCESS);
}
客户端程序client.c,这个程序用于向服务器发送消息,并接收来自服务器的回复。
#include "client.h"
intmain()
{
intserver_fifo_fd;
intclient_fifo_fd;
intres;
charclient_fifo_name[NAME_SIZE];
message msg;
msg.client_pid = getpid();
sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid);
if(mkfifo(client_fifo_name, 0777) == -1)
{
fprintf(stderr, "Sorry, create client fifo failure!/n");
exit(EXIT_FAILURE);
}
server_fifo_fd = open(SERVER_FIFO_NAME, O_WRONLY);
if(server_fifo_fd == -1)
{
fprintf(stderr, "Sorry, open server fifo failure!/n");
exit(EXIT_FAILURE);
}
sprintf(msg.data, "Hello from %d", msg.client_pid);
printf("%d sent %s ", msg.client_pid, msg.data);
write(server_fifo_fd, &msg, sizeof(msg));
client_fifo_fd = open(client_fifo_name, O_RDONLY);
if(client_fifo_fd == -1)
{
fprintf(stderr, "Sorry, client fifo open failure!/n");
exit(EXIT_FAILURE);
}
res = read(client_fifo_fd, &msg, sizeof(msg));
if(res > 0)
{
printf("received:%s/n", msg.data);
}
close(client_fifo_fd);
close(server_fifo_fd);
unlink(client_fifo_name);
exit(EXIT_SUCCESS);
}
#include "client.h"
int main()
{
int server_fifo_fd;
int client_fifo_fd;
int res;
char client_fifo_name[NAME_SIZE];
message msg;
msg.client_pid = getpid();
sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid);
if (mkfifo(client_fifo_name, 0777) == -1)
{
fprintf(stderr, "Sorry, create client fifo failure!/n");
exit(EXIT_FAILURE);
}
server_fifo_fd = open(SERVER_FIFO_NAME, O_WRONLY);
if (server_fifo_fd == -1)
{
fprintf(stderr, "Sorry, open server fifo failure!/n");
exit(EXIT_FAILURE);
}
sprintf(msg.data, "Hello from %d", msg.client_pid);
printf("%d sent %s ", msg.client_pid, msg.data);
write(server_fifo_fd, &msg, sizeof(msg));
client_fifo_fd = open(client_fifo_name, O_RDONLY);
if (client_fifo_fd == -1)
{
fprintf(stderr, "Sorry, client fifo open failure!/n");
exit(EXIT_FAILURE);
}
res = read(client_fifo_fd, &msg, sizeof(msg));
if (res > 0)
{
printf("received:%s/n", msg.data);
}
close(client_fifo_fd);
close(server_fifo_fd);
unlink(client_fifo_name);
exit(EXIT_SUCCESS);
}
编译程序:
gcc –o server
server.c
gcc –o client
client.c
测试这个程序,我们需要一个服务器进程和多个客户进程。为了让多个客户进程在同一时间启动,我们使用了shell命令:
[root@localhost chaper12]# ./server
&
[26] 5171
[root@localhost chaper12]# for i in
1 2 3 4 5; do ./client & done
[27] 5172
[28] 5173
[29] 5174
[30] 5175
[31] 5176
[root@localhost chaper12]# 5172
sent Hello from 5172 received:HELLO FROM 5172
5173 sent Hello from 5173
received:HELLO FROM 5173
5174 sent Hello from 5174
received:HELLO FROM 5174
5175 sent Hello from 5175
received:HELLO FROM 5175
5176 sent Hello from 5176
received:HELLO FROM 5176
分析这个例子,服务器以只读模式创建它的FIFO并阻塞,直到第一个客户以写方式打开同一现个FIFO来建立连接为止。此时,服务器进程解除阻塞并执行sleep语句,这使得来自客户的数据排除等候。在实际应用程序中,应该把sleep语句删除,这里面只是为了演示当有多个客户请求同时到达时,程序的正确操作方法。
与此同时,在客户端打开服务器FIFO后,它创建自己唯一的一个命名管道以读取服务器返回的数据。完成这些工作后,客户发送数据给服务器(如果管道满或服务器仍处于休眠就阻塞),并阻塞于对自己FIFO的read调用上,等待服务器响应。
接收到来自客户的数据后,服务器处于它,然后以写的方式打开客户管道并将处理后的数据返回,这将解除客户端的阻塞状态,客户程序就可以从自己的管道里面读取服务器返回的数据了。
整个处理过程不断重复,直到最后一个客户关闭服务器管道为止,这将使服务器的read调用失败(返回0),因为已经没有进程以写方式打开服务器管道了。如果这是一个真正的服务器进程的话,它还需要继续等待其他客户的请求,我们就需要对它进行修改,有两种方法:
(1)对它自己的服务器管道打开一个文件描述符,这样read调用将阻塞而不是返回0。
(2)当read调用返回0时,关闭并重新打开服务器管道,使服务器进程阻塞在open调用处以等待客户的到来,就像它最初启动时那样。
linux 管道文件上机总结,[转载]LINUX 管道 fifo 等总结相关推荐
- linux下jtag命令,[转载]LINUX内核调试过程(使用OpenJtag + OpenOCD)
[转载]LINUX内核调试过程(使用OpenJtag + OpenOCD) (2012-04-12 02:02:27) 标签: 杂谈 [转载]LINUX内核调试过程(使用OpenJtag + Open ...
- Linux非系统盘挂载,[转载] Linux mount 挂载分区、硬盘
mount用于Linux系统挂载各种存储设备,如硬盘.分区.通常的用法 mount -t [文件系统] -o [选项参数] 设备分区 挂载点 例如 mount -t ext4 -o uid=501,g ...
- linux下日志rorate,[转载]linux下日志分割logrotate 设置和理解
对于Linux 的系统安全来说,日志文件是极其重要的工具.系统管理员能使用logrotate 程式用来管理系统中的最新的事件,对于Linux 的系统安全来说,日志文件是极其重要的工具.系统管理员能使用 ...
- linux打开core文件,[转载]linux下core文件设置与查看
程序异常推出时,内核会生成一个core文件(是内存映像以及调试信息).可以通过使用gdb来查看core文件,指示出导致程序出错的代码所在的文件和行数. 1.查看系统中core文件生成的开关是否打开 1 ...
- linux 下显卡优化,[转载]Linux 下 NVIDIA 显卡闭源驱动的一些优化
完全搬运,原文请猛戳 NVIDIA 对开源驱动开发的支持之差从 Linus Torvalds 那句著名的"Fuck NVIDIA"就可见一斑--几乎没有提供任何开发文档,开源驱动的 ...
- linux ifort编译命令,[转载][Linux] icc与ifort编译器
1.icc Intel C/C++编译器接受遵守ANSI C/C++ , ISO C/C++ standards,GNU inline ASM for IA-32 architecture标准的输入. ...
- linux fortran 内存不足,[转载]linux 安装fortran 90 --zz
安装fortran 90 1 安装前需要的支持 1.1 环境Ubuntu10.04系统,(如果是其他系统可以跳过第2步) 1.2 安装库支持和alien等 sudo apt-get install b ...
- linux批量下载数据,[转载]linux shell批量下载IGS或CORS网FTP数据
最近用迅雷FTP探测器下载数据,下载好之后发现漏下了好多数据,所以使用linux wget命令来实现FTP数据批量下载 关于wget命令可以 用wget --help 查看帮助,简单说明一下: wge ...
- linux 脚本竖线表示,[转载]Linux shell中的竖线(|)——管道符号
vim一些常用的快捷键 快速注释: Ctrl+v I // esc 打开文件 gf ctrl+o MyBatis入门(五)---延时加载.缓存 一.创建数据库 1.1.建立数据库 /* SQLyog ...
最新文章
- 九度OJ 区间问题 10000个随机正负数生成
- 充电桩系统php源码,源码 充电桩程序设计 - 下载 - 搜珍网
- 操作系统(10)-虚拟内存
- 用螺纹铣刀铣螺纹转速进给怎么设_机加工中最常用的几种钨钢铣刀刀具介绍
- 【机器人操作系统】ROS工作空间及功能包的创建
- C#基于RabbitMQ实现客户端之间消息通讯实战演练
- jvm虚拟机_JVM虚拟机JVM简介
- 一个非常强大的静态导航网站nav
- dojo实现省份地市级联---省份数据源
- web前端开发前景如何
- 计算机组装与维护doc,《计算机组装与维护》课程教案.doc
- nrr评分预测_NRR的完整形式是什么?
- hdu 2122 最小生成树
- 输入的数字或者英文字符间距都特别大,怎么解决
- 2022湖北省各市专精特新小巨人企业认定补贴、条件流程
- 我又来分享来了,发现一个好的ide,免费的国产的,优秀的,自带md阅读器.那就是uni-app
- Mybatis系列2:模板模式在Mybatis中的执行器中的应用
- Java实验01 Java编程基础(猜数字游戏、随机点名器)
- ciscn_2019_n_7(exit_hook)、wdb_2018_1st_babyheap(fsop的例子)
- 数据结构视频知识点整理 1