需要在每条消息后关闭读取端的linux FIFO
在Linux中，FIFO（First In First Out）是一种特殊的文件类型，也被称为命名管道。它允许不同进程之间通过文件进行通信，其中一个进程将数据写入FIFO，而另一个进程则从FIFO中读取数据。
要在每条消息后关闭读取端的Linux FIFO，可以按照以下步骤进行操作：
- 创建FIFO：使用mkfifo命令创建一个FIFO文件，例如：
- 创建FIFO：使用mkfifo命令创建一个FIFO文件，例如：
- 打开读取端和写入端：在两个不同的终端窗口中打开FIFO的读取端和写入端，例如：
- 打开读取端和写入端：在两个不同的终端窗口中打开FIFO的读取端和写入端，例如：
- 关闭读取端：在读取端读取完一条消息后，可以关闭读取端，例如：
- 关闭读取端：在读取端读取完一条消息后，可以关闭读取端，例如：
- 在这种情况下，读取端会一直等待新的消息，直到再次打开读取端或者写入端写入新的消息。
关闭读取端的优势是可以控制消息的读取时机，避免不必要的等待。这在某些场景下可能是有用的，例如在多进程通信中，读取端可能需要等待特定条件满足后才能读取消息。
关于Linux FIFO的应用场景，它可以用于各种进程间通信的场景，例如父子进程通信、多线程通信等。它的特点是简单易用，不需要复杂的网络通信设置，适用于本地进程间通信。
腾讯云提供了一系列与云计算相关的产品，包括云服务器、云数据库、云存储等。具体针对Linux FIFO的相关产品可能没有直接的对应，但可以通过腾讯云的云服务器（CVM）来搭建Linux环境，并使用Linux原生的FIFO功能进行进程间通信。
更多关于腾讯云产品的信息，可以参考腾讯云官方网站：腾讯云。
相关·内容
1回答
从命名管道读取
、、、
我必须实现一个“打印服务器”。我有一个客户端文件和一个服务器文件：
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
int get_line( char *dest, int size );
#define MAX 1024
void main ()
{
char
浏览 0提问于2014-05-06得票数 4
回答已采纳
1回答
我正在尝试使用POSIX IPC在Linux下的C++中实现一个运行时可重新配置的IPC。在当前配置中，我有一个进程A通过FIFO与进程B通信。进程B从FIFO获取数据，进行一些修改，并通过另一个FIFO将数据发送到另一个进程C。这是一个图形表示：
然后，在运行时，我想杀死进程B，并允许进程A通过B和C之间的FIFO发送数据：
我该怎么做呢？
浏览 16提问于2017-01-24得票数 1
1回答
我试图在Linux中编写一个简单的守护进程，它将创建一个FIFO，然后收集写入FIFO的任何内容，并在稍后将数据写入文件。
我的期望是，一旦我的守护进程创建了FIFO，我就可以重复执行"echo text > /myfifo“。当我做完了，我可以做“回显退出> /myfifo”，我的程序将退出并将所有数据写入磁盘。
我目前正在使用poll()来了解FIFO上什么时候有更多的数据。这很好，直到我第一次回显数据到FIFO之后。数据得到了很好的回音，但是我的民意测验在那之后不断地返回SIGHUP。
是否需要在每个进程写入FIFO之后重新设置(或关闭和重新打开)呢？
我代码的伪代码
浏览 2提问于2010-07-11得票数 1
2回答
我一直试图把我的头脑围绕FIFO，并提出了一个简单的程序服务器和客户端。
我并不想做任何花哨的事情，我只是想让一个进程扮演“服务器”的角色，这个进程将“监听”由另一个进程(客户端)传递的任何消息。
以下是我写的：
server.c
#include<stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#define INGOING "clientToServer.fifo"
#define BUFFER 200
int main(int argc, char *argv[]) {
浏览 2提问于2014-05-02得票数 9
回答已采纳
1回答
我编写了以下两个程序，其中一个程序连续地将字符串写入缓冲区，并将其通过FIFO传递给另一个程序，后者读取我所传递的内容。
/*write*/
int main()
{
int i=0, fd1;
char buffer[16];
mkfifo("fifo1", 0666);
fd1 = open("fifo1", O_WRONLY);
for(;;)
{
sprintf(buffer, "string%d", i);
write(fd1, buffer, 16)
浏览 3提问于2017-04-25得票数 0
2回答
我正在学习linux fifo，我做了两个小的C程序，它们通过fifo进行通信。第一个类似于服务器，它接收模式并使用该模式执行命令。第二个类似于客户端，它发送模式并接收结果。我希望服务器能够服务多个请求，但不一定是同时服务的，但奇怪的是，在第一个客户端被服务之后，它就停止了，尽管我在那里放了一个无限循环。
server.c
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <signal.h>
#include <fcntl.h>
v
浏览 1提问于2013-07-22得票数 0
回答已采纳
1回答
我一直在为大学做项目，其中我有一些小脚本在一个简单的数据库(例如选择信息)上执行操作，这是一个服务器脚本，它通过一个名为server.pipe的管道接收来自客户端脚本的各种实例的请求，并通过单个客户机的命名管道返回它们的结果(通常是几行文本文件)。
对于多行响应，我尝试在客户机中使用while循环来继续从管道中读取数据，我使用了如下所示：
read response < $id.pipe
while [ $response != "end_result" ]; do
echo $response
read response < $id.pipe
这有
浏览 0提问于2018-11-24得票数 0
回答已采纳
2回答
如果我有一些随机进程从命名管道读取：
tail -f MYNAMEDPIPED
cat MYNAMEDPIPE | someOtherProc
在其他地方，我有一个关于MYNAMEDPIPED的名字。是否有一种安全而干净的方法，通过删除MYNAMEDPIPED或以某种方式“干燥它”来阻止尾部过程？
换句话说
MYNAMEDPIPED.noMoreDataIsComingThroughSoPleaseStopTailingThis()
:)
从其中一个评论，它说要发送EOF到MYNAMEDPIPE。但我不知道该怎么做。
这表明我所面临的困难：
http://comp.os.linux.ques
浏览 0提问于2017-07-07得票数 8
2回答
我试着用FIFO做些简单的事情:读几行，但不是一遍一遍，它出乎意料地“不起作用”。
这是可以的：
$ f=$(mktemp -u)
$ mkfifo $f
$ { seq 5 > $f; } &
[1] 2486
$ while read line; do echo $line; done < $f
1
2
3
4
5
[1]+ Done { seq 10 > $f; }
但如果我试着逐个读行，第一读成功，第二读挂起。
$ { seq 5 > $f; } &
[1] 2527
$ read line < $f
浏览 3提问于2014-04-15得票数 5
回答已采纳
我有一个用于Linux的小型内部Python脚本，它在用户的$HOME目录中创建一个/home/user/environ_script.sh文件，然后通过
subprocess.call('bash --rcfile /home/user/environ_script.sh')
脚本运行得很好，但我想知道这是否可以在根本不写入磁盘的情况下完成？类似于bash的进程替换命令
foo <(command)
通过临时文件句柄/dev/fdx提供"command“输出作为foo的输入，因为foo需要一个文件句柄。
浏览 0提问于2011-12-23得票数 1
回答已采纳
2回答
我已经在linux mkfifo /tmp/myFIFO中创建了一个管道，现在我已经将chmod设置为777。然后我有一个c应用程序，它读取管道并输出我写到管道中的内容。
当我在php中这样做的时候，这是有效的..
$command = "echo 'helloworld' > myFIFO";
$process = proc_open($command, $descriptor, $pipes, $cwd, $env);
但是当我用fwrite来做的时候，例如
$out = fopen("/tmp/myFIFO","w")
浏览 2提问于2012-10-29得票数 4
我有一个FIFO队列，我一个接一个地发送4条消息。在发送前4条消息之后，我运行了一个程序来接收它们，但是只返回了2条消息--即使使用长轮询和max messages = 10。
我又发了4条消息--现在我一共收到8条信息。AWS用于接收消息的SQS UI和我用于接收消息的代码都只显示了2条消息，但表示有8条消息可用。
在发送了4条消息之后，您可以在附带的屏幕截图中看到，SQS显示了12条可用消息，但只列出了2条消息，而且我有C#代码来接收带有长轮询的消息，这些消息也只返回2条消息。
我看到所有可用的信息，我做错了什么？
浏览 3提问于2020-09-13得票数 3
1回答
我正在构建一个服务器，通过FIFO与它的客户端进行通信。
到目前为止，我已经成功地创建了一个FIFO，运行了一个新的线程，一旦消息到达FIFO并从线程输出消息。
问题是，一旦客户端在管道中写入某些内容，服务器就会无休止地打印消息(我正在从while(1)中的管道中读取消息)。
我的问题是：read操作不也应该从管道中删除消息，这样就不会再读取消息了吗？这不是第一，第一个Out的意义吗？那是我必须手动做的事吗？
这也是我的代码，如果这有帮助的话：
我在FIFO中所做的就是：echo test > /home/ubuntu/work/my_fifo
浏览 2提问于2013-04-21得票数 1
回答已采纳
1回答
我正在尝试使用FIFO在两个进程之间进行读写，但是当我打开一个FIFO时，它没有打印我给它打印的任何消息，类似地，当我写入它时，它也没有显示任何东西...so，我怎么知道它是否工作呢？为什么它挂在终端上它只是一直接受输入而不结束?请在这里帮助我，我认为代码是正确的，但它是这样的
int main ()
{
int fd;
char buffer[MAX];
char * os;
if(mkfifo("oss",0666)<0)
{
perror("FIFO (named pipe) could not
浏览 1提问于2014-04-17得票数 0
2回答
读取FIFO时未定义的行为
、、、、
我试图通过命名管道/FIFO将javascript的数据发送到C。除了每一对消息之外，所有东西似乎都正常工作，会有一个额外的循环迭代来读取0字节，而不是预期的256。我意识到我可以添加一些类似if (bytes_read>0) {...的东西，但这似乎是一个更大的问题的创可贴。
从我的测试来看，当open()打开并且关闭文件时，writer中的调用似乎被解除阻塞。看起来，有时reader已经为下一条消息做好了准备(并在打开时被阻塞)，在writer关闭以前的文件之前，这样它将在每条消息中运行两次循环。
这只是预期的行为还是我误解了什么？任何建议都会得到极大的认可！
作者：
uint32_
浏览 9提问于2022-07-08得票数 1
回答已采纳
我正在学习Linux中的管道编程，并且很难理解管道/ FIFO管理。
我编写了一个小程序，它打开了我创建的FIFO (在执行程序之前，我在我的终端中做了mkfifo newfifo )。然后，我反复读取和转储我的字符缓冲区。我正在使用来自另一个终端的cmd行的echo "message" > newfifo填充FIFO。
问题是，当我写入FIFO时，我可以在缓冲区中读取数据，但是读取不再阻塞。我的理解是，在我从FIFO读取数据之后，FIFO应该是空的，读取应该是阻塞的。我是想错了，还是我不正确地管理FIFO？
代码如下：
#include <stdio.h>
浏览 3提问于2015-03-20得票数 1
回答已采纳
1回答
在以下IPC选项列表中，可以执行多播(即一个发送方和多个接收方)：
信号
半双工管
命名管
系统V消息队列
unix域套接字
编辑
内存映射文件
根据我的理解，命名管道可能是可能的(不确定)。
浏览 3提问于2015-02-28得票数 6
回答已采纳
1回答
带有FIFO问题的输入循环
、、、、
我在使用FIFO作为标准输入时遇到了一些问题。
我有一个这样的脚本：
#!/usr/bin/env ruby
while true do
data = gets
puts "Got: #{data}"
end
然后我像这样运行它：
$ ./script < input.fifo &
$ echo testdata > input.fifo
它将打印如下内容：
Got: testdata
Got:
Got:
Got:
Got:
Got:
etc.
我怀疑FIFO出了点问题。有些东西在被发送到脚本后不会被清除。
我用一个使用scanf("
浏览 0提问于2013-01-06得票数 0
1回答
带FIFO的Fork()
、、、、
我在这项任务中遇到了最艰难的时刻。所以在这个赋值中，我有两个孩子(两个独立的程序)，他们必须写到父程序(main)。家长必须从孩子那里读取两个数据，然后将其打印出来。我必须使用命名管道。我的先进先出一直给我"USAGE: NAMEPIPECLIENTString“信息，我不知道为什么。顺便说一句，消息在客户端。另外，如果有人能给我指出一个好的方向，告诉我如何在单独的文件中使用fork和multiply子文件，那将是非常感谢的。提前感谢！使用GNU C
我的读者
#include<unistd.h>
#include<stdio.h>
#include<st
浏览 2提问于2016-04-29得票数 0
1回答
我正在编写一个Linux fifo测试程序。
我使用mkfifo mpipe创建了一个管道。程序应该在发送给它的每个参数中执行一次写操作。如果没有发送参数，则从管道执行一次读取。
这是我的密码
int main(int argc, char *argv[])
{
if (argc > 1)
{
int fd = open("./mpipe", O_WRONLY);
int i = 1;
for (i; i < argc; i++)
{
int bytes = write(f
浏览 0提问于2018-06-06得票数 2
回答已采纳
2回答
我在linux中有一个命名管道，我想从python中读取它。问题是python进程不断地“消耗”一个核心(100%)。我的代码如下：
FIFO = '/var/run/mypipe'
os.mkfifo(FIFO)
with open(FIFO) as fifo:
while True:
line = fifo.read()
我想问的是，“睡眠”是否会对这种情况有所帮助，或者进程会丢失一些来自管道的输入数据。我不能控制输入，所以我不知道数据输入的频率。我读过关于select和poll的文章，但我没有为我的问题找到任何示例。最后，我想问一下，100%的使用
浏览 0提问于2016-08-23得票数 23
回答已采纳
2回答
我正在使用Tornado运行一个小python程序，该程序收集由另一个程序编写的多个linux命名管道(FIFO)输出。不幸的是，由于某种原因，并非所有来自管道的输出都被接收到。
我像这样添加管道：
for pipe in pipe_files:
pipe_file = open(pipe, 'r')
try:
pipe_stream = PipeIOStream(pipe_file.fileno())
self.output_streams.append(pipe_stream)
except IOError:
浏览 0提问于2015-04-20得票数 1
这是我的简单代码，它打开一个命名管道，向其中写入一个字符串，然后关闭该管道。管道是在另一个函数中创建的，如下所述。
char * ipcnm = "./jobqueue";
std::cout << "opening job queue" << std::endl;
//ensure the jobqueue is opened
if ((jobq = open(ipcnm, O_WRONLY)) < 0) {
perror("open");
exit(-1);
}
std::cout <<
浏览 2提问于2014-06-08得票数 5
回答已采纳
1回答
我有一个可能会将大量数据输出到stdout的命令，我需要通过ftp将其上传到远程位置。 我发现了这个问题，Upload output of a program directly to a remote file by ftp，我真的很喜欢将输出重定向到命名管道中，然后从其中读取垃圾的想法。但是，只要我通过dd读取第一个块，输入到管道中的命令就会退出，并且没有更多的数据可以从管道中读取。 为了测试这个，我创建了一个fifo #> mkfifo fifo 然后我在一个shell上写入fifo： #> echo bla > fifo 在另一个shell上，我从上面读到： #&g
浏览 37提问于2018-12-17得票数 1
我只是在Ubuntu中做了一个命名管道的实验，但是服务器不能接收我在客户机中输入的字符串，我如何解决它呢？当我在客户机中按Ctrl+C时，服务器可以接收一些字符。
服务器
#include<stdio.h>
#include<stdlib.h>
#include<sys/stat.h>
#include<unistd.h>
#include<linux/stat.h>
#define FIFO_FILE "sampleFIFO"
int main()
{
FILE *fp;
char readbuf
浏览 2提问于2013-08-13得票数 0
回答已采纳
1回答
我有一个简单的C程序，它使用来自RabbitMQ的消息并销毁它。它消耗了500万条信息。
#include <stdio.h>
#include <stdlib.h>
#include <amqp.h>
int main() {
/* connect to broker */
amqp_connection_state_t rabbit_conn = amqp_new_connection();
if (rabbit_conn == NULL) {
printf("cannot create AMQP co
浏览 12提问于2014-09-09得票数 2
回答已采纳
我正在用C语言实现一个管道，其中多个生产者程序(在我的例子中是9个)将数据写入一个单一的消费者程序。 问题是一些生产者(有时一两次)在调用write()函数时突然退出程序。 代码很简单，下面是生产者代码： #include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include &l
浏览 40提问于2019-01-11得票数 3
回答已采纳
1回答
我正在制作一个非常简单的程序，它由客户端使用的一个小API和一个服务器进程组成。客户端进程和服务器进程通过两个FIFO通信(一个带有对服务器的请求，另一个带有来自服务器的响应)。
服务器继续用阻塞读取(O_RDWR标志)读取请求FIFO。客户端在请求FIFO (O_WRONLY标志)上写入请求，服务器读取请求，并在响应FIFO (O_WRONLY标志)上写入响应。客户机读取响应(O_RDONLY标志)：如果服务器没有通信任何数据(我指的是未定义的长缓冲区)，则FIFO上的响应就足够了，并且工作完成了O_RDWR.客户机读取服务器将要发送数据的响应，因此它再次打开响应FIFO (O_RDONLY
浏览 0提问于2011-05-21得票数 1
1回答
从后台获取用户输入
、、、
我试图完成的是让一个进程在Linux终端的后台运行，它接受用户输入并根据输入执行操作，即使终端窗口没有被聚焦，这样我就可以使用其他GUI应用程序，然后当我按下一些预定义的按钮时，可能会改变程序的状态，而不会失去当前窗口的焦点。就这么简单(虽然对我来说没那么简单)。
我并不要求特定类型的实现。我对任何可能工作的东西都没意见: C、C++、Java、Linux Bash script……唯一的必要条件是它能在Linux下工作。
非常感谢
浏览 3提问于2013-07-30得票数 0
QNX procmgr_guardian中有一个函数，可以在父进程死亡的情况下将子进程设置为另一个子进程的监护人。Linux中也有这样的功能吗？我如何在Linux中实现它？感谢任何人的指点。
浏览 6提问于2011-08-03得票数 0
2回答
我正在创建一个相当大的项目，作为家庭作业，我需要创建一个服务器程序，它可以听2个fifos，客户可以在那里编写。
一切正常工作，但有件事让我很生气:每当我做一个操作，它是由客户端和服务器之间的一些写/读组成的，当我在客户端上关闭fifos时，看起来服务器“认为”仍然有人在打开fifos。
因此，服务器在每次操作后尝试读取64字节，显然失败(读取0字节)。每次操作只有一次--发生这种情况，它不再试图读取64字节的
它不会给客户带来任何问题，但这真的很奇怪，我讨厌那些类型的bug
我认为这是一个与打开/关闭和客户端使用锁有关的问题。
注意，在打开操作中使用的标志是在这个伪代码文本中指定的。
服务器
浏览 3提问于2011-09-12得票数 1
回答已采纳
我需要构建两个程序:一个服务器和一个C中的客户机，它们实现如下：
当我启动服务器时，他会创建一个命名管道(O_RDONLY)来阻塞自己，直到客户端连接。
客户端使用用O_WRONLY打开的命名管道向客户端发送一个msg，解锁服务器。
服务器接收消息，然后将该消息传递给一个在屏幕上打印消息的子节点(使用匿名管道)。
1. If the child process isn't created, the parent creates one
2. The child is supposed to read from the anonymous pipe **1** mes
浏览 0提问于2014-05-30得票数 0
1回答
嗨!
我有一个C赋值，在这里我需要创建一个命名管道(FIFO)，让两个子进程在父进程读取这些行(并处理接收到的数据)时将行写入其中。我对这个话题很陌生-- fd锁定，管道，等等--我不太理解基本的管道。现在我正在处理这个结构：
在父进程从管道读取时，管道(mkfifo)parent使两个子进程同时将(fork)children写行写入管道，在每次迭代中都遵循以下步骤：打开文件descriptorwrite/read it关闭文件descriptor。
在我看来，他们似乎有些纠结，而父进程并没有把所有的行都写进管道中(至少当我不让孩子们睡觉时，他们不会同时工作)。
是否有一种简洁的方法可以在写完
浏览 4提问于2022-05-15得票数 0
我使用Amazon队列向外部系统发送通知。
如果在使用SQS‘SendMessage时HTTP请求失败，我不知道消息是否已排队。我的默认策略是重发消息到队列中，但是有可能会将消息发送两次，根据用例的不同，这可能是不可接受的。
如果消息主体上有一个副本(或者某种消息元数据，例如我们可以提供的唯一ID )，那么是否有一种方法让SQS拒绝消息，以便我们可以重试直到消息被接受为止，并且确信如果第一个请求已经排队，但是响应已经丢失了，那么就不会有重复的消息了？
浏览 2提问于2013-09-09得票数 5
回答已采纳
2回答
我对IPC使用命名管道。有时，进程之间发送的数据可能很大且频繁。在这段时间里，我看到很多数据丢失。下面的代码中有没有什么明显的问题会导致这种情况呢？
谢谢
#!/usr/bin/env groovy
import java.io.FileOutputStream;
def bytes = new File('/etc/passwd').bytes
def pipe = new File('/home/mohadib/pipe')
1000.times{
def fos = new FileOutputStream(pipe)
fos.write(
浏览 0提问于2011-02-02得票数 1
回答已采纳
1回答
当我回显Linux中某些任意位置的文件时，例如echo > /tmp/file，一些正在运行的进程会响应。这是通过文件管道的IPC吗？
这是否意味着正在运行的进程总是打开要读取的文件？但是，既然文件流被它自己的进程锁定，那么如何写入文件呢？
浏览 1提问于2012-06-16得票数 5
回答已采纳
我有一个小型服务器，编写如下：
async def handle_client(reader, writer):
request = (await reader.read()).decode('utf8') # should read until end of msg
print(request)
response = "thx"
writer.write(response.encode('utf8'))
await writer.drain()
writer.close()
loop = as
浏览 0提问于2020-12-11得票数 3
回答已采纳
语境与问题
最近，我一直在为我正在做的一个大学项目找名字的管道。我需要制作一个充当“服务器”的程序--它不断地从一个命名管道读取数据，并通过所述管道执行任何命令。我设法做到这一点，但有一个问题: 100%的CPU使用率。显然，这是一个问题，这将有助于降低我的教授的分数，所以我想减少这一点。
编辑:我忘记提到，在从管道中读取消息并执行它之后，服务器必须继续运行，等待另一条消息。服务器程序绝不能终止(除非发送SIGINT或类似的信号)。所需的行为是它永远不要离开循环，只需继续读取和执行管道发送的消息。
“服务器”代码的最小可复制示例：
#include <unistd.h>
#incl
浏览 2提问于2021-06-06得票数 1
回答已采纳
我正在尝试从我的树莓派传输一条简单的消息，它是客户端到我的计算机，它是服务器。我正在为tcpClient使用cpp，为tcpServer使用java。这是我的TCPServer.java：
import java.net.*;
import java.io.*;
class TCPServer extends Thread {
TCPClass() {
}
public void connect(){
try {
ServerSocket welcomeSocket = new ServerSocket();
浏览 0提问于2016-07-12得票数 1
1回答
我有两个进程，一个服务器和一个客户机，应该通过管道(C++，Linux)进行通信。服务器使用O_RDONLY标志打开管道，用O_WRONLY打开客户端。但是，服务器在open函数处阻塞，而客户机似乎成功运行( open函数返回成功，write函数也一样)。
我读过，如果设置了O_NONBLOCK标志，读取函数就会继续，但是如果没有连接到客户端，我不希望它继续--在客户端连接之前阻止是可以的，但在我的示例中，即使在客户端运行完之后，它仍然被阻塞。
请告诉我我做错了什么.？
以下是代码：
// Server side
int pipe;
int status, nr_read = 0;
stat
浏览 3提问于2012-09-11得票数 5
回答已采纳
当我与g_io_channel一起使用FIFO时，我正试图理解为什么我的CPU与100%挂钩。
我在上有一个项目，它演示了最小可能设置的问题；只是一个在/tmp中打开FIFO的简单服务器，以及一个通过FIFO向服务器发送消息的客户机。
我发现：
当第一次启动时，服务器占用的CPU几乎为零。
一旦客户端通过FIFO向服务器发送消息，服务器就会接收并打印该消息，然后CPU将达到100%。
您可以继续通过FIFO发送消息，服务器将打印它们，但是CPU保持在100% :-/
我试过通常的谷歌，堆栈溢出，但到目前为止，没有joy找到解决方案。我希望有人能帮我理解这是怎么回事。我相信我
浏览 1提问于2018-05-01得票数 2
回答已采纳
我已经创建了一个FIFO (使用mkfifo())，我需要等待某些进程将数据写入其中几次。我编写了以下代码：(忽略糟糕的样式，以保持示例的简洁性)
int count = 0, read = 0;
while(count < 2) {
read = read(fd, buf, BUFFER_SIZE);
if(read > 0) {
//do work...
count++;
}
}
为了避免忙忙碌碌的等待，我添加了以下一行：
int count = 0, read = 0;
while(count < 2) {
浏览 0提问于2016-04-30得票数 1
1回答
我在学校接到一项任务，要用C语言( Linux)写一个FTP程序。我很快就得到了所有的基本功能(ls，cd)，但我在文件传输部分遇到了问题。我使用sendfile通过套接字发送文件，如下所示：
int fd = open(temp, O_RDONLY);
int rc = sendfile (client_fd, fd, &offset, statbuf.st_size);
我似乎不知道如何在客户端接收这个文件。我试着这样调试：
while( (i = read(sock, message, MSG_LEN - 1)) > 0 ) {
message[i] = &#
浏览 0提问于2010-12-08得票数 0
回答已采纳
2回答
在linux中，我使用node-tail读取文件并将其发送到套接字。
node.js发送从文本文件读取的数据
var io = require('socket.io');
Tail = require('tail').Tail;
tail = new Tail("/tmp/test.txt");
io.sockets.on('connection', function (socket) {
tail.on("line", function(data) {
socket.emit('Messag
浏览 2提问于2013-05-22得票数 2
回答已采纳
在Linux上，我使用mkfifo /tmp/test在shell中创建了一个命名管道。 我想将其用于异步读取，因此作为第一步，我将使用AsynchronousFileChannel打开它 java.nio.channels.AsynchronousFileChannel.open(
java.nio.file.Paths.get("/tmp/test"),
java.nio.file.StandardOpenOption.READ)
) 但是，调用挂起： "main" #1 prio=5 os_prio=0 cpu=1830.11ms ela
浏览 24提问于2020-04-25得票数 0
1回答
我的问题类似于"根据同一字段中的排序值合并两个排序文件“，但将其扩展到命名管道。
假设我有两个带有排序整数的文本文件，我想要合并它们。我可以使用sort -nm file1.txt file2.txt > merged.txt进行一次不阻塞的合并.
现在，假设这些文件实际上是我正在制作的管道(FIFO)，然后在python中填充。只要我交替写一个管道，然后再写一个管道，我就可以做到这一点。此代码用于生成两个有序的整数列表，将它们写入由sort子进程读取的命名管道，该子进程将合并的结果输出到单个文件中：
import tempfile
import subprocess
impor
浏览 0提问于2019-06-06得票数 1
我有一个检查管道是否存在的程序，它是在一个函数中编写的：
status = mkfifo("recv",0666);
fd1 = open("recv",O_WRONLY);
fd2 = open("sendd", O_RDONLY);
cout<<"we are checking botth bcz we have both read and write in the program------:)";
if(fd1 <0 && fd2 <0)
{
//strerror(errno
浏览 1提问于2013-08-16得票数 0
回答已采纳
1回答
我在socket编程中为计算引擎编写了一个服务器程序，它显示客户端给出的数字的平均值。我的客户端代码：
main()
{
//socket
//connect
gets(msg);
f=sscanf(msg,"%f",&num);
write(sockfd,msg,strlen(msg));
while ((n1=read(sockfd,result,Z))>0) {
write(1,result,n1);
}
}
在服务器中：
while((rfd=read(sockfd,buff,Z))&
浏览 0提问于2012-10-01得票数 0
回答已采纳
我正在试验生锈的命名管道，我想要创建一个服务器，它接收来自客户端的永远不会结束的消息。
//reciever.rs
use libc::{c_char, mkfifo};
use std::ffi::CString;
use std::fs::OpenOptions;
use std::io::Read;
fn main() {
let _ = std::fs::remove_file("rust-fifo");
let name_fifo = CString::new("rust-fifo").unwrap();
let name_f
浏览 3提问于2021-12-26得票数 0
回答已采纳
我正在使用Popen执行一个shell脚本。我还使用stdout=PIPE来捕获output.The代码
pipe = Popen('acbd.sh', shell=True, stdout = PIPE)
while pipe.poll() is None:
time.sleep(0.5)
text = pipe.communicate()[0]
if pipe.returncode == 0:
print "File executed"
根据与一起使用轮询的文档，stdout=可能导致死锁。另外，可以使用communicate()来解
浏览 2提问于2017-01-17得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
