CHAPTER 11. STREAMS, FILES, AND NETWORKING
577
by the attributes of the element. If element is a variable that refers to the node, the color can
be obtained by saying:
int r = Integer.parseInt( element.getAttribute("red") );
int g = Integer.parseInt( element.getAttribute("green") );
int b = Integer.parseInt( element.getAttribute("blue") );
Color bgColor = new Color(r,g,b);
Suppose now that element refers to the node that represents the element
<symmetric>true</symmetric>
In this case, the element represents the value of a boolean variable, and the value is encoded
in the textual content of the element. We can recover the value from the element with:
String bool = element.getTextContent();
boolean symmetric;
if (bool.equals("true"))
symmetric = true;
else
symmetric = false;
Next, consider an example that uses a NodeList. Suppose we encounter an element that repre-
sents a list of Points:
<pointlist>
<point x=’17’ y=’42’/>
<point x=’23’ y=’8’/>
<point x=’109’ y=’342’/>
<point x=’18’ y=’270’/>
</pointlist>
Suppose that element refers to the node that represents the <pointlist> element. Our goal
is to build the list of type ArrayList<Point> that is represented by the element. We can do
this by traversing the NodeList that contains the child nodes of element:
ArrayList<Point> points = new ArrayList<Point>();
NodeList children = element.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node child = children.item(i);
// One of the child nodes of element.
if ( child instanceof Element ) {
Element pointElement = (Element)child; // One of the <point> elements.
int x = Integer.parseInt( pointElement.getAttribute("x") );
int y = Integer.parseInt( pointElement.getAttribute("y") );
Point pt = new Point(x,y); // Create the Point represented by pointElement.
points.add(pt);
// Add the point to the list of points.
}
}
All the nested <point> elements are children of the <pointlist> element. The if statement
in this code fragment is necessary because an element can have other children in addition to its
nested elements. In this example, we only want to process the children that are elements.
All these techniques can be employed to write the file input method for the sample program
SimplePaintWithXML.java.WhenbuildingthedatastructurerepresentedbyanXMLfile,my
approach is to start with a default data structure and then to modify and add to it as I traverse
the DOM representation of the file. It’s not a trivial process, but I hope that you can follow it:
Pdf security options - C# PDF Digital Signature Library: add, remove, update PDF digital signatures in C#.net, ASP.NET, MVC, WPF
Help to Improve the Security of Your PDF File by Adding Digital Signatures
pdf secure signature; create pdf the security level is set to high
Pdf security options - VB.NET PDF Digital Signature Library: add, remove, update PDF digital signatures in vb.net, ASP.NET, MVC, WPF
Guide VB.NET Programmers to Improve the Security of Your PDF File by Adding Digital Signatures
advanced pdf encryption remover; pdf file security
CHAPTER 11. STREAMS, FILES, AND NETWORKING
578
Color newBackground = Color.WHITE;
ArrayList<CurveData> newCurves = new ArrayList<CurveData>();
Element rootElement = xmldoc.getDocumentElement();
if ( ! rootElement.getNodeName().equals("simplepaint") )
throw new Exception("File is not a SimplePaint file.");
String version = rootElement.getAttribute("version");
try {
double versionNumber = Double.parseDouble(version);
if (versionNumber > 1.0)
throw new Exception("File requires a newer version of SimplePaint.");
}
catch (NumberFormatException e) {
}
NodeList nodes = rootElement.getChildNodes();
for (int i = 0; i < nodes.getLength(); i++) {
if (nodes.item(i) instanceof Element) {
Element element = (Element)nodes.item(i);
if (element.getTagName().equals("background")) { // Read background color.
int r = Integer.parseInt(element.getAttribute("red"));
int g = Integer.parseInt(element.getAttribute("green"));
int b = Integer.parseInt(element.getAttribute("blue"));
newBackground = new Color(r,g,b);
}
else if (element.getTagName().equals("curve")) { // Read data for a curve.
CurveData curve = new CurveData();
curve.color = Color.BLACK;
curve.points = new ArrayList<Point>();
newCurves.add(curve); // Add this curve to the new list of curves.
NodeList curveNodes = element.getChildNodes();
for (int j = 0; j < curveNodes.getLength(); j++) {
if (curveNodes.item(j) instanceof Element) {
Element curveElement = (Element)curveNodes.item(j);
if (curveElement.getTagName().equals("color")) {
int r = Integer.parseInt(curveElement.getAttribute("red"));
int g = Integer.parseInt(curveElement.getAttribute("green"));
int b = Integer.parseInt(curveElement.getAttribute("blue"));
curve.color = new Color(r,g,b);
}
else if (curveElement.getTagName().equals("point")) {
int x = Integer.parseInt(curveElement.getAttribute("x"));
int y = Integer.parseInt(curveElement.getAttribute("y"));
curve.points.add(new Point(x,y));
}
else if (curveElement.getTagName().equals("symmetric")) {
String content = curveElement.getTextContent();
if (content.equals("true"))
curve.symmetric = true;
}
}
}
}
.NET PDF SDK - Description of All PDF Processing Control Feastures
Easy to change PDF original password; Options for setting PDF security level; PDF text content, image and pages redact options. PDF Digital Signature.
secure pdf remove; create secure pdf
.NET Annotation SDK| Annotate, Redact Images
Rich options to move, resize, rotate, scale any kind of annotation; Provide enhanced redaction & encryption objects for sensitive information & security;
decrypt pdf; decrypt password protected pdf
CHAPTER 11. STREAMS, FILES, AND NETWORKING
579
}
}
curves = newCurves; // Change picture in window to show the data from file.
setBackground(newBackground);
repaint();
∗ ∗ ∗
XML has developed into an extremely important technology, and some applications of it are
very complex. But there is a core of simple ideas that can be easily applied in Java. Knowing
just the basics, you can make good use of XML in your own Java programs.
BMP to JPEG Converter | Convert Bitmap to JPEG, Convert JPEG to
to JPEG Converter provides flexible image processing related options to resize JPEG conversion; Add morphing effects, watermarks to images to protect security;
add security to pdf in reader; convert secure pdf to word
DICOM to PDF Converter | Convert DICOM to PDF, Convert PDF to
Start DICOM - PDF image conversion through drag &drop method; Security protection provided with comment, logo, date or watermarks added to files;
pdf security options; create secure pdf online
Exercises
580
Exercises for Chapter 11
1. The sample programDirectoryList.java, given as an example inSubsection 11.2.2, will
(solution)
print a list of files in a directory specified by the user. But some of the files in that
directory might themselves be directories. And the subdirectories can themselves contain
directories. And so on. Write a modified version of DirectoryList that will list all the
files in a directory and all its subdirectories, to any level of nesting. You will need a
recursive subroutine to do the listing. The subroutine should have a parameter of type
File. You will need the constructor from the File class that has the form
public File( File dir, String fileName )
// Constructs the File object representing a file
// named fileName in the directory specified by dir.
2. Write a program that will count the number of lines in each file that is specified on the
(solution)
commandline. Assume that the files are text files. Note that multiple files can be specified,
as in:
java LineCounts file1.txt file2.txt file3.txt
Write each file name, along with the number of lines in that file, to standard output. If an
error occurs while trying to read from one of the files, you should print an error message
for that file, but you should still process all the remaining files. Do not use TextIO to
process the files; use a Scanner, a BufferedReader, or a TextReader to process each file.
3. For this exercise, you will write a network server program. The program is a simple file
(solution)
server that makes a collection of files available for transmission to clients. When the server
starts up, it needs to know the name of the directory that contains the collection of files.
This information can be provided as a command-line argument. You can assume that the
directory contains only regular files (that is, it does not contain any sub-directories). You
can also assume that all the files are text files.
When a client connects to the server, the server first reads a one-line command from
the client. The command can be the string “index”. In this case, the server responds by
sending a list of names of all the files that are available on the server. Or the command can
be of the form “get <filename>”, where <filename> is a file name. The server checks
whether the requested file actually exists. If so, it first sends the word “ok” as a message
to the client. Then it sends the contents of the file and closes the connection. Otherwise,
it sends the word “error” to the client and closes the connection.
Write a subroutine to handle each request. See the DirectoryList example inSub-
section 11.2.2forhelpwiththeproblemofgettingthelistoffilesinthedirectory.
4. Write a client program for the server from Exercise 11.3. Design a user interface that will
(solution)
let the user do at least two things: (1) Get a list of files that are available on the server
and display the list on standard output; and (2) Get a copy of a specified file from the
server and save it to a local file (on the computer where the client is running).
5. The sample program PhoneDirectoryFileDemo.java, from Subsection 11.3.2, stores
(solution)
name/number pairs for a simple phone book in a text file in the user’s home directory.
Modify that program so that it uses an XML format for the data. The only significant
C# Image: Run RasterEdge Web Viewer Sample Project
Right-click the correspond site-> Edit Permissions -> Security -> Group or user names to provide powerful & profession imaging controls, PDF document, image to
decrypt password protected pdf; pdf password unlock
JPEG2000 to JBIG2 Converter | Convert JPEG2000 to JBIG2, Convert
or batch conversion method; Convert GIF & JBIG2 image with morphing effects, watermarks added to protect security; Can be used as
create pdf security; advanced pdf encryption remover
Exercises
581
changes that you will have to make are to the parts of the program that read and write
the data file. Use the DOM to read the data, as discussed inSubsection11.5.3. You can
use the XML format illustrated in the following sample phone directory file:
<?xml version="1.0"?>
<phone
directory>
<entry name=’barney’ number=’890-1203’/>
<entry name=’fred’ number=’555-9923’/>
</phone
directory>
(This is just an easy exercise in simple XML processing; as before, the program in this
exercise is not meant to be a useful phone directory program.)
6. The sample programCheckers.javafromSubsection7.5.3 lets two players play checkers.
(solution)
It would be nice if, in the middle of a game, the state of the game could be saved to a file.
Later, the file could be read back into the file to restore the game and allow the players to
continue. Add the ability to save and load files to the checkers program. Design a simple
text-based format for the files. Here is a picture of my solution to this exercise, just after
afile has been loaded into the program:
Note: The original checkers program could be run as either an applet or a stand-alone
application. Since the new version uses files, however, it can only be run as an application.
An applet running in a web browser is not allowed to access files.
It’s a little tricky to completely restore the state of a game. The program has a
variable board of type CheckersData that stores the current contents of the board, and it
has a variable currentPlayer of type int that indicates whether Red or Black is currently
moving. This data must be storedin thefile when afile is saved. When afile is read into the
program, you should read the data into two local variables newBoard of type CheckersData
and newCurrentPlayer of type int. Once you have successfully read all the data from
the file, you can use the following code to set up the program state correctly. This code
assumes that you have introduced two new variables saveButton and loadButton of type
JButton to represent the “Save Game” and “Load Game” buttons:
GIF to JBIG2 Converter | Convert GIF to JBIG2, Convert JBIG2 to
brightness and more; Convert GIF & JBIG2 image with morphing effects, watermarks added to protect security; Save original images &
copy text from encrypted pdf; pdf security settings
Exercises
582
board = newBoard; // Set up game with data read from file.
currentPlayer = newCurrentPlayer;
legalMoves = board.getLegalMoves(currentPlayer);
selectedRow = -1;
gameInProgress = true;
newGameButton.setEnabled(false);
loadButton.setEnabled(false);
saveButton.setEnabled(true);
resignButton.setEnabled(true);
if (currentPlayer == CheckersData.RED)
message.setText("Game loaded -- it’s RED’s move.");
else
message.setText("Game loaded -- it’s BLACK’s move.");
repaint();
(Note, by the way, that I used a TextReader to read the data from the file into my
program. TextReader is a non-standard class introduced inSubsection11.1.4 and defined
in the file TextReader.java. How to read the data in a file depends, of course, on the
format that you have chosen for the data.)
Quiz
583
Quiz on Chapter 11
(answers)
1. In Java, input/output is done using streams. Streams are an abstraction. Explain what
this means and why it is important.
2. Java has two types of streams: character streams and byte streams. Why? What is the
difference between the two types of streams?
3. What is a file? Why are files necessary?
4. What is the point of the following statement?
out = new PrintWriter( new FileWriter("data.dat") );
Why would you need a statement that involves two different stream classes, PrintWriter
and FileWriter?
5. The package java.io includes a class named URL. What does an object of type URL
represent, and how is it used?
6. What is the purpose of the JFileChooser class?
7. Explain what is meant by the client / server model of network communication.
8. What is a socket?
9. What is a ServerSocket and how is it used?
10. What is meant by an element in an XML document?
11. What is it about XML that makes it suitable for representing almost any type of data?
12. Write a complete program that will display the first ten lines from a text file. The lines
should be writtentostandard output, System.out. The filename is givenas the command-
line argument args[0]. You can assume that the file contains at least ten lines. Don’t
bother to make the program robust. Do not use TextIO to process the file; use a FileReader
to access the file.
Chapter 12
Threads and Multiprocessing
I
nthe classic programming model, there is a single central processing unit that reads
instructions from memory and carries them out, one after the other. The purpose of a program
is to provide the list of instructions for the processor to execute. This is the only type of
programming that we have considered so far.
However, this model of programming has limitations. Modern computers have multiple
processors, making it possible for them to perform several tasks at the same time. To use the
full potential of all those processors, you will need to write programs that can do parallel
processing. For Java programmers, that means learning about threads. A single thread is
similar to the programs that you have been writing up until now, but more than one thread
can be running at the same time, “in parallel.” What makes things more interesting—and
more difficult—than single-threaded programming is the fact that the threads in a parallel
program are rarely completely independent of one another. They usually need to cooperate
and communicate. Learning to manage and control cooperation among threads is the main
hurdle that you will face in this chapter.
There are several reasons to use parallel programming. One is simply to do computations
more quickly by setting several processors to work on them simultaneously. Just as important,
however, is to use threads to deal with “blocking” operations, where a process can’t proceed
until some event occurs. In the previous chapter, for example, we saw how programs can block
while waiting for data to arrive over a network connection. Threads make it possible for one
part of a program to continue to do useful work even while another part is blocked, waiting for
some event to occur. In this context, threads are a vital programming tool even for a computer
that has only a single processing unit.
12.1 Introduction to Threads
L
ike people, computers can multitask. That is, they can be working on several different
(online)
tasks at the same time. A computer that has just a single central processing unit can’t literally
do two things at the same time, any more than a person can, but it can still switch its attention
back and forth among several tasks. Furthermore, it is increasingly common for computers to
have more than one processing unit, and such computers can literally work on several tasks
simultaneously. It is likely that from now on, most of the increase in computing power will
come from adding additional processors to computers rather than from increasing the speed of
individual processors. To use the full power of these multiprocessing computers, a programmer
must do parallel programming, which means writing a program as a set of several tasks that
584
CHAPTER 12. THREADS AND MULTIPROCESSING
585
can be executed simultaneously. Even on a single-processor computer, parallel programming
techniques can be useful, since some problems can be tackled most naturally by breaking the
solution into a set of simultaneous tasks that cooperate to solve the problem.
In Java, a single task is called a thread. The term“thread” refers to a“thread of control” or
“thread of execution,” meaning a sequence of instructions that are executed one after another—
the thread extends through time, connecting each instruction to the next. In a multithreaded
program, there can be many threads of control, weaving through time in parallel and forming
the complete fabric of the program. (Ok, enough with the metaphor, already!) Every Java
program has at least one thread; when the Java virtual machine runs your program, it creates a
thread that is responsible for executing the main routine of the program. This main thread can
in turn create other threads that can continue even after the main thread has terminated. In a
GUI program, there is at least one additional thread, which is responsible for handling events
and drawing components on the screen. This GUI thread is created when the first window is
opened. So in fact, you have already done parallel programming! When a main routine opens a
window, both the main thread and the GUI thread can continue to run in parallel. Of course,
parallel programming can be used in much more interesting ways.
Unfortunately, parallel programming is even more difficult than ordinary, single-threaded
programming. When several threads are working together on a problem, a whole new category
of errors is possible. This just means that techniques for writing correct and robust programs
are even more important for parallel programming than they are for normal programming.
On the other hand, fortunately, Java has a nice thread API that makes basic uses of threads
reasonably easy. It also has some standard classes to help with some of the more tricky parts.
It won’t be until midway throughSection12.3 that you’ll learn about the low-level techniques
that are necessary to handle the trickiest parts of parallel programming.
12.1.1 Creating and Running Threads
In Java, a thread is represented by an object belonging to the class java.lang.Thread (or to
asubclass of this class). The purpose of a Thread object is to execute a single method and to
execute it just once. This method represents the task to be carried out by the thread. The
method is executed in its own thread of control, which can run in parallel with other threads.
When the execution of the thread’s method is finished, either because the method terminates
normally or because of an uncaught exception, the thread stops running. Once this happens,
there is no way to restart the thread or to use the same Thread object to start another thread.
There are two ways to program a thread. One is to create a subclass of Thread and to define
the method public void run() in the subclass. This run() method defines the task that will
be performed by the thread; that is, when the thread is started, it is the run() method that
will be executed in the thread. For example, here is a simple, and rather useless, class that
defines a thread that does nothing but print a message on standard output:
public class NamedThread extends Thread {
private String name; // The name of this thread.
public NamedThread(String name) { // Constructor gives name to thread.
this.name = name;
}
public void run() { // The run method prints a message to standard output.
System.out.println("Greetings from thread ’" + name + "’!");
}
}
CHAPTER 12. THREADS AND MULTIPROCESSING
586
To use a NamedThread, you must of course create an object belonging to this class. For
example,
NamedThread greetings = new NamedThread("Fred");
However, creating the object does not automatically start the thread running or cause its run()
method to be executed. To do that, you must call the start() method in the thread object.
For the example, this would be done with the statement
greetings.start();
The purpose of the start() method is to create the new thread of control that will execute the
Thread object’s run() method. The new thread runs in parallel with the thread in which the
start() method was called, along with any other threads that already existed. The start()
method returns immediately after starting the new thread of control, without waiting for
the thread to terminate. This means that the code in the thread’s run() method executes
at the same time as the statements that follow the call to the start() method. Consider this
code segment:
NamedThread greetings = new NamedThread("Fred");
greetings.start();
System.out.println("Thread has been started");
After greetings.start() is executed, there are two threads. One of them will print “Thread
has been started” while the other one wants to print “Greetings from thread ’Fred’!”. It is
important to note that these messages can be printed in either order. The two threads run
simultaneously and will compete for access to standard output, so that they can print their
messages. Whichever thread happens to be the first to get access will be the first to print its
message. In a normal, single-threaded program, things happen in a definite, predictable order
from beginning to end. In a multi-threaded program, there is a fundamental indeterminacy.
You can’t be sure what order things will happen in. This indeterminacy is what makes parallel
programming so difficult!
Note that calling greetings.start() is very different from calling greetings.run().
Calling greetings.run() would execute the run() method in the same thread, rather than
creating a new thread. This means that all the work of the run() will be done before the
computer moves on to the statements that follow the call to greetings.run(). There is no
parallelism and no indeterminacy.
Documents you may be interested
Documents you may be interested