1.1 Java Terms
Let's start by defining some terms
used throughout this book. Many Java-related terms are used
inconsistently in various sources; we endeavor to be consistent in
our usage of these terms throughout the book.
- Java
-
First, is the term Java
itself. As you know, Java started out as a programming language, and
many people today still think of Java as being simply a programming
language. But Java is much more than just a programming language:
it's also an API specification and a virtual machine
specification. So when we say Java, we mean the entire Java platform:
the programming language, its APIs, and a virtual machine
specification that, taken together, define an entire programming and
runtime environment. Often when we say Java, it's
clear from the context that we're talking
specifically about the programming language, or parts of the Java
API, or the virtual machine. The point to remember is that the
threading features we discuss in this book derive their properties
from all the components of the Java platform taken as a whole. While
it's possible to take the Java programming language,
directly compile it into assembly code, and run it outside of the
virtual machine, such an executable may not necessarily behave the
same as the programs we describe in this book.
- Virtual machine, interpreters, and browsers
-
The Java virtual machine is the code that
actually runs a Java program. Its purpose is to interpret the
intermediate bytecodes that Java programs are compiled into; the
virtual machine is sometimes called the Java
interpreter.
However, modern virtual machines usually compile the majority of the
code they run into native instructions as the program is executing;
the result is that the virtual machine does little actual
interpretation of code.
Browsers such as Mozilla,
Netscape Navigator, Opera, and
Internet Explorer all have the capability to run certain Java programs
(applets).
Historically, these browsers had an embedded virtual machine; today,
the standard Java virtual machine runs as a plug-in to these
browsers. That means that the threading details of Java-capable
browsers are essentially identical to those of a standard Java
virtual machine. The one significant area of difference lies in some
of the default thread security settings for browsers (see Chapter 13).
Virtual machine implementations are available from many different
vendors and for many different operating systems. For the most part,
virtual machines are indistinguishable梐t least in theory.
However, because threads are tied to the operating system on which
they run, platform-specific differences in thread behavior do crop
up. These differences are important in relatively few circumstances,
and we discuss them in Chapter 9.
- Programs, applications, applets, and other code
-
This leads us to the terms that we use for things written in the Java
language. Like traditional programming models, Java supports the idea
of a standalone
application, which
in the case of Java is run from the command line (or through a
desktop chooser or icon). The popularity of Java has led to the
creation of many new types of Java-enabled containers that run pieces
of Java code called
components.
Web server containers allow you to write components (servlets and
Java Server Page or JSP classes) that run inside the web server.
Java-enabled browsers allow you to write applets: classes that run
inside the Java plug-in. Java 2 Enterprise Edition
(J2EE) application servers execute Enterprise Java Beans
(EJBs), servlets,
JSPs, and so on. Even databases now provide the ability to use
server-side Java components.
As far as Java threads are concerned, the distinction between the
different types of
containers is
usually only the location of the objects to be executed. Certain
containers place restrictions on threaded operations (which we
discuss in Chapter 13), and in that case, we
discuss specific components. Apart from the rare case where we
specifically mention a type of component, we just use the term
program since the concepts discussed apply to all of the Java code
you might write.
- Concurrency and threads
-
J2SE 5.0 includes a
package known as the
"concurrency
utilities," or JSR-166. Concurrency is a broad term.
It includes the ability to perform multiple tasks at the same time;
we generally refer to that ability as parallelism. As
we'll see throughout this book, threaded programming
is about more than parallelism: it's also about
simpler program design and coping with certain implementation
features of the Java platform. The features of Java (including those
of JSR-166) help us with these tasks as well.
Concurrency also includes the ability to access data at the same time
in two or more threads. These are issues of data synchronization,
which is the term we use when discussing those aspects of
concurrency.
1.1.1 Java Versions, Tools, and Code
We also need to be concerned with specific
versions of Java
itself. This is an artifact of the popularity of Java, which has led
to several major enhancements in the platform. Each version
supplements the thread-related classes available to developers,
allowing them to work with new features or no longer to rely on
externally developed classes.
We focus in this book on J2SE 5.0. This version
contains a wealth of new thread-related classes and features. These
classes greatly simplify much of the work in developing threaded
applications since they provide basic implementations of common
threading paradigms.
The new features of J2SE 5.0 are integrated throughout the
Java platform; we've integrated the new features
throughout our discussion as well. When we discuss J2SE 5.0, we
clearly identify the new features as such. If you're
unable to use those features because you cannot yet upgrade the
version of Java you're using,
you'll find similar functionality to almost all J2SE
5.0 features in the classes provided in the Appendix A, which contains implementations of common
threading utilities that were developed in previous versions of this
book;
these utilities use an earlier version of Java.
|
It's interesting to note the differences between
this edition of Java Threads and the previous
editions. In earlier editions of this book, we developed classes to
perform explicit locks, condition variables, thread pooling, task
scheduling, and so on. All that functionality and more is now
included in the core J2SE 5.0 platform. In Chapter 14, we look at thread performance; the
performance of basic thread-related operations (and especially
uncontended lock acquisition) has greatly improved since we first
looked at this in JDK 1.1. And in order to obtain meaningful,
long-running results for our parallelism tests in Chapter 15, we had to increase the number of
calculations by a significant factor.
|
|
