perldoc > select(2)

    select FILEHANDLE
    select  Returns the currently selected filehandle. If FILEHANDLE is
            supplied, sets the new current default filehandle for output.
            This has two effects: first, a "write", "print", or "say"
            without a filehandle default to this FILEHANDLE. Second,
            references to variables related to output will refer to this
            output channel.

            For example, to set the top-of-form format for more than one
            output channel, you might do the following:

                select(REPORT1);
                $^ = 'report1_top';
                select(REPORT2);
                $^ = 'report2_top';

            FILEHANDLE may be an expression whose value gives the name of
            the actual filehandle. Thus:

                my $oldfh = select(STDERR); $| = 1; select($oldfh);

            Some programmers may prefer to think of filehandles as objects
            with methods, preferring to write the last example as:

                STDERR->autoflush(1);

            (Prior to Perl version 5.14, you have to "use IO::Handle;"
            explicitly first.)

            Whilst you can use "select" to temporarily "capture" the output
            of "print" like this:

                {
                    my $old_handle = select $new_handle;

                    # This goes to $new_handle:
                    print "ok 1\n";
                    ...

                    select $old_handle;
                }

            you might find it easier to localize the typeglob instead:

                {
                    local *STDOUT = $new_handle;

                    print "ok 1\n";
                    ...
                }

            The two are not exactly equivalent, but the latter might be
            clearer and will restore STDOUT if the wrapped code dies. The
            difference is that in the former, the original STDOUT can still
            be accessed by explicitly using it in a "print" statement (as
            "print STDOUT ..."), whereas in the latter the meaning of the
            STDOUT handle itself has temporarily been changed.

            Portability issues: "select" in perlport.

    select RBITS,WBITS,EBITS,TIMEOUT
            This calls the select(2) syscall with the bit masks specified,
            which can be constructed using "fileno" and "vec", along these
            lines:

                my $rin = my $win = my $ein = '';
                vec($rin, fileno(STDIN),  1) = 1;
                vec($win, fileno(STDOUT), 1) = 1;
                $ein = $rin | $win;

            If you want to select on many filehandles, you may wish to write
            a subroutine like this:

                sub fhbits {
                    my @fhlist = @_;
                    my $bits = "";
                    for my $fh (@fhlist) {
                        vec($bits, fileno($fh), 1) = 1;
                    }
                    return $bits;
                }
                my $rin = fhbits(\*STDIN, $tty, $mysock);

            The usual idiom is:

             my ($nfound, $timeleft) =
               select(my $rout = $rin, my $wout = $win, my $eout = $ein,
                                                                      $timeout);

            or to block until something becomes ready just do this

             my $nfound =
               select(my $rout = $rin, my $wout = $win, my $eout = $ein, undef);

            Most systems do not bother to return anything useful in
            $timeleft, so calling "select" in scalar context just returns
            $nfound.

            Any of the bit masks can also be "undef". The timeout, if
            specified, is in seconds, which may be fractional. Note: not all
            implementations are capable of returning the $timeleft. If not,
            they always return $timeleft equal to the supplied $timeout.

            You can effect a sleep of 250 milliseconds this way:

                select(undef, undef, undef, 0.25);

            Note that whether "select" gets restarted after signals (say,
            SIGALRM) is implementation-dependent. See also perlport for
            notes on the portability of "select".

            On error, "select" behaves just like select(2): it returns -1
            and sets $!.

            On some Unixes, select(2) may report a socket file descriptor as
            "ready for reading" even when no data is available, and thus any
            subsequent "read" would block. This can be avoided if you always
            use "O_NONBLOCK" on the socket. See select(2) and fcntl(2) for
            further details.

            The standard "IO::Select" module provides a user-friendlier
            interface to "select", mostly because it does all the bit-mask
            work for you.

            WARNING: One should not attempt to mix buffered I/O (like "read"
            or "readline") with "select", except as permitted by POSIX, and
            even then only on POSIX systems. You have to use "sysread"
            instead.

            Portability issues: "select" in perlport.