Java IO.pdf - Nguyen Dang Binh

}
}
catch (IOException e) {
// probably just an end of stream exception
}
Java I/O
Example 8.5 is the FibonacciDriver class. It creates a piped output stream and a piped input
stream and uses those to construct FibonacciWriter and FibonacciReader objects. These
streams are a channel of communication between the two threads. As data is written by the
FibonacciWriter thread it becomes available for the FibonacciReader thread to read. Both
the FibonacciWriter and the FibonacciReader are run with normal priority so when the
FibonacciWriter blocks or is preempted, the FibonacciReader runs and vice versa.
Example 8.5. The FibonacciDriver Class
import java.io.*;
public class FibonacciDriver {
}
public static void main (String[] args) {
}
int howMany;
try {
howMany = Integer.parseInt(args[0]);
}
catch (Exception e) {
howMany = 20;
}
try {
PipedOutputStream pout = new PipedOutputStream();
PipedInputStream pin = new PipedInputStream(pout);
FibonacciWriter fw = new FibonacciWriter(pout, howMany);
FibonacciReader fr = new FibonacciReader(pin);
fw.start();
fr.start();
}
catch (IOException e) { System.err.println(e);}
You may be wondering how the piped streams differ from the stream copiers presented earlier
in the book. The first difference is that the piped stream moves data from an output stream to
an input stream. The stream copier always moves data in the opposite direction, from an input
stream to an output stream. The second difference is that the stream copier actively moves the
data by calling the read() and write() methods of the underlying streams. A piped output
stream merely makes the data available to the input stream. It is still necessary for some other
object to invoke the piped input stream's read() method to read the data. If no other object
reads from the piped input stream, then after about one kilobyte of data has been written onto
the piped output stream, the writing thread will block while it waits for the piped input
stream's buffer to empty out.
139