Reading from Many Filehandles Without Blocking (Perl Cookbook, 2nd Edition)

## 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

Copyright © 2003 O'Reilly & Associates. All rights reserved.