我正在寻找一个类似于shell命令X的东西，当我执行以下命令时：
command_a | X 5000 | command_b
command_a的stdout会在至少5秒后被写入到command_b的stdin中。
这是一种延迟缓冲。
据我所知，buffer/mbuffer可以以恒定速率（每秒固定字节数）写入。相反，我需要一个恒定的时间延迟（t=0时，X读取command_a输出块，在t=5000时必须将此块写入command_b）。
[编辑] 我已经实现了它：https://github.com/rom1v/delay
我知道你说你正在寻找一个shell命令，但是你考虑过利用子shell吗？像这样：
command_a | (sleep 5; command_b)
因此，要通过已经使用cat命令打开的文件进行grep操作（我知道，这是很糟糕的cat用法，只是一个例子）：
cat filename | (sleep 5; grep pattern)
$ cat testfile
The
quick
brown
fox
$ cat testfile | (sleep 5; grep brown)
# A 5-second sleep occurs here
brown
甚至按照Michale Kropat的建议，使用带有sleep命令的组合命令也可以工作(并且可能更正确)。像这样：
$ cat testfile | { sleep 5; grep brown; }
grep brown ），因为这是必要的！由于似乎没有这样的命令，我用C语言实现了它：https://github.com/rom1v/delay
delay [-b <dtbufsize>] <delay>
catdelay，pipedelay，buffdelay，... - grebneke#!/bin/bash
while :
do
read line
sleep 5
echo $line
done
chmod +x slowboy
并作为运行
command_a | ./slowboy | command_b
这可能会起作用
time_buffered () {
delay=$1
while read line; do
printf "%d %s\n" "$(date +%s)" "$line"
done | while read ts line; do
now=$(date +%s)
if (( now - ts < delay)); then
sleep $(( now - ts ))
fi
printf "%s\n" "$line"
done
}
commandA | time_buffered 5 | commandB
$delay秒后才输出该行。ioctl），仅在Linux上进行了测试。# Measure max throughput:
$ pv < /dev/zero | ./buffer_delay.pl > /dev/null
# Interactive manual test, use two terminal windows:
$ mkfifo data_fifo
terminal-one $ cat > data_fifo
terminal-two $ ./buffer_delay.pl < data_fifo
# now type in terminal-one and see it appear delayed in terminal-two.
# It will be line-buffered because of the terminals, not a limitation
# of buffer_delay.pl
buffer_delay.pl
#!/usr/bin/perl
use strict;
use warnings;
use IO::Select;
use Time::HiRes qw(gettimeofday usleep);
require 'sys/ioctl.ph';
$|++;
my $delay_usec = 3 * 1000000; # (3s) delay in microseconds
my $buffer_size_max = 10 * 1024 * 1024 ; # (10 Mb) max bytes our buffer is allowed to contain.
# When buffer is full, incoming data will not be read
# until space becomes available after writing
my $read_frequency = 10; # Approximate read frequency in Hz (will not be exact)
my %buffer; # the data we are delaying, saved in chunks by timestamp
my @timestamps; # keys to %buffer, used as a queue
my $buffer_size = 0; # num bytes currently in %buffer, compare to $buffer_size_max
my $time_slice = 1000000 / $read_frequency; # microseconds, min time for each discrete read-step
my $sel = IO::Select->new([\*STDIN]);
my $overflow_unread = 0; # Num bytes waiting when $buffer_size_max is reached
while (1) {
my $now = sprintf "%d%06d", gettimeofday; # timestamp, used to label incoming chunks
# input available?
if ($overflow_unread || $sel->can_read($time_slice / 1000000)) {
# how much?
my $available_bytes;
if ($overflow_unread) {
$available_bytes = $overflow_unread;
}
else {
$available_bytes = pack("L", 0);
ioctl (STDIN, FIONREAD(), $available_bytes);
$available_bytes = unpack("L", $available_bytes);
}
# will it fit?
my $remaining_space = $buffer_size_max - $buffer_size;
my $try_to_read_bytes = $available_bytes;
if ($try_to_read_bytes > $remaining_space) {
$try_to_read_bytes = $remaining_space;
}
# read input
if ($try_to_read_bytes > 0) {
my $input_data;
my $num_read = read (STDIN, $input_data, $try_to_read_bytes);
die "read error: $!" unless defined $num_read;
exit if $num_read == 0; # EOF
$buffer{$now} = $input_data; # save input
push @timestamps, $now; # save the timestamp
$buffer_size += length $input_data;
if ($overflow_unread) {
$overflow_unread -= length $input_data;
}
elsif (length $input_data < $available_bytes) {
$overflow_unread = $available_bytes - length $input_data;
}
}
}
# write + delete any data old enough
my $then = $now - $delay_usec; # when data is old enough
while (scalar @timestamps && $timestamps[0] < $then) {
my $ts = shift @timestamps;
print $buffer{$ts} if defined $buffer{$ts};
$buffer_size -= length $buffer{$ts};
die "Serious problem\n" unless $buffer_size >= 0;
delete $buffer{$ts};
}
# usleep any remaining time up to $time_slice
my $time_left = (sprintf "%d%06d", gettimeofday) - $now;
usleep ($time_slice - $time_left) if $time_slice > $time_left;
}
请在下方自由发表评论和建议！
pv测试了我的程序，吞吐量始终等于缓冲区大小除以延迟时间。在相同的参数下（3秒延迟，10Mb缓冲区），我获得了3.33Mb/s的吞吐量：pv < /dev/zero | delay 3s -b10m > /dev/null。 - rom1v
X -d 5000 -s 2m）。 - rom1v