Perl Cd Bookshelf [Electronic resources] نسخه متنی

7.22. Reading from Many Filehandles Without Blocking

7.22.1. Problem

You want to learn whether input
is available to be read, rather than blocking until there's input the
way <FH> does. This is useful when reading
from pipes, sockets, devices, and other
programs.

7.22.2. Solution

Use
select with a timeout value of 0 seconds if you're
comfortable with manipulating bit-vectors representing file
descriptor sets:

$rin = ";
# repeat next line for all filehandles to poll
vec($rin, fileno(FH1), 1) = 1;
vec($rin, fileno(FH2), 1) = 1;
vec($rin, fileno(FH3), 1) = 1;
$nfound = select($rout=$rin, undef, undef, 0);
if ($nfound) {
# input waiting on one or more of those 3 filehandles
if (vec($rout,fileno(FH1),1)) {
# do something with FH1
}
if (vec($rout,fileno(FH2),1)) {
# do something with FH2
}
if (vec($rout,fileno(FH3),1)) {
# do something with FH3
}
}

The
IO::Select module provides an abstraction layer to hide bit-vector
operations:

use IO::Select;
$select = IO::Select->new( );
# repeat next line for all filehandles to poll
$select->add(*FILEHANDLE);
if (@ready = $select->can_read(0)) {
# input waiting on the filehandles in @ready
}

7.22.3. Discussion

The select function is really two functions in
one. If you call it with one argument, you change the current default
output filehandle (see Recipe 7.19). If you
call it with four arguments, it tells you which filehandles have
input waiting or are ready to receive output. This recipe deals only
with four-argument select.

The first three arguments to select are strings
containing bit-vectors. Each bit-vector represents a set of file
descriptors to inspect for pending input, pending output, and pending
expedited data (like out-of-band or urgent data on a socket),
respectively. The final argument is the timeout—how long
select should spend waiting for status to change.
A timeout value of 0 indicates a poll. Timeout can also be a
floating-point number of seconds, or undef to wait
(block) until status changes:

$rin = ";
vec($rin, fileno(FILEHANDLE), 1) = 1;
$nfound = select($rin, undef, undef, 0);    # just check
if ($nfound) {
# read ten bytes from FILEHANDLE
sysread(HANDLE, $data, 10);
print "I read $data";
}

The IO::Select
module hides the bit-vectors from you. IO::Select->new(
) returns a new object on which you invoke the
add method to add one or more filehandles to the
set. Once you've added the filehandles you are interested in, invoke
can_read, can_write, or
has_exception. These methods return a list of
filehandles that you can safely read from or write to, or that have
unread exceptional data (TCP out-of-band data, for example).

If you want to read an entire line of data, you can't use the
readline function or the
<FH> line input operator (unless you use an
unbuffered I/O layer). Otherwise, you'll mix a buffered I/O function
with a check that ignores those buffers in user space and cares only
about what's buffered in kernel space. This is a big no-no. For
details on this and directions for calling sysread
on whatever is available on a socket or pipe and then returning
immediately, see Recipe 7.23. If you're
trying to do non-blocking reads on a terminal line (that is, on a
keyboard or other serial line device), see Recipe 15.6 and Recipe 15.8.

7.22.4. See Also

The select function in
perlfunc(1) and in Chapter 29 of
Programming Perl; the documentation for the
standard module IO::Select (also in Chapter 32 of
Programming Perl); Recipe 7.20; Recipe 7.23