Chapter 12. Threads and I/O
If you're not interested in parallel processing, the
area where you're most likely to encounter threads
in Java is in dealing with I/O梐nd particularly in dealing with
network I/O. That's the topic we explore in this
chapter.
In early versions of Java, all I/O was blocking. If your program
attempted to read data from a socket and no data was present, the
read() method would block until at least some
data was available. That situation is also true of reading a file.
For the most part, delays in reading files aren't
noticeable; you may have to wait a few cycles for the disk to rotate
to the correct location and the operating system to transfer data
from the disk. In most programs, blocking for that amount of time
makes little difference, but in those programs where it does make a
difference, the concepts that apply to network I/O are just as
relevant to file I/O.
For network I/O, the delay can be quite significant. Networks are
subject to delays at various points (particularly if the network
involves long distances or slow links). Even if
there's no physical delay on the network lines,
network I/O is done in the context of a conversation between two
peers, and a peer may not be ready to furnish its output when its
partner wants it. A database server reads commands from a user, but
the user may take a few minutes to type in the SQL to be executed.
Once the SQL has been sent to the database, the user is ready to read
back the response, but it may take the database a few minutes to
obtain the results of the query.
Because early versions of Java did not have a way to handle
nonblocking I/O, Java servers would typically start a new thread for
every client that connected to them. Java clients would typically
start a new thread to send requests to the server so that the rest of
the program would remain active while the client was waiting for a
response.
In JDK 1.4, this situation changed: Java introduced the NIO package,
which allowed developers to utilize nonblocking I/O in their
programs. This changed the rule for the way in which Java servers
(and other I/O-intensive programs) are threaded, though it does not
eliminate all threading considerations from those programs.
In this chapter, we look at servers that employ each type of I/O and
show common techniques for handling the server's
threads.
| 
