What's New in This Edition?
This edition includes information about
J2SE 5.0. One of the most
significant changes in J2SE 5.0 is the inclusion of
Java Specification
Request (JSR) 166, often referred to as the
"concurrency
utilities." JSR-166 specifies a number of
thread-related enhancements to existing
APIs as well as
providing a large package of new APIs.
These new APIs include:
- Atomic variables
-
A set of classes that provide threadsafe operations without
synchronization
- Explicit locks
-
Synchronization locks that can be acquired and released
programmatically
- Condition variables
-
Variables that can be the subject of a targeted notification when
certain conditions exist
- Queues
-
Collection classes that are thread-aware
- Synchronization primitives
-
New classes that perform complex types of synchronization
- Thread pools
-
Classes that can manage a pool of threads to run certain tasks
- Thread schedulers
-
Classes that can execute tasks at a particular point in time
We've fully integrated the new features of J2SE 5.0
throughout the text of this edition. The new features can be split
into three categories:
- New implementations of existing features
-
The Java language has always had the capability to perform data
synchronization and thread notification. However, implementation of
these features was somewhat limited; you could, for example,
synchronize blocks of code or entire methods but synchronizing across
methods and classes required extra programming. In J2SE 5.0, explicit
locks and condition variables allow you more flexibility when using
these features.
These new implementations do not introduce new concepts for a
developer. A developer who wants to write a threadsafe program must
ensure that her data is correctly synchronized, whether she uses J2SE
5.0's explicit locks or the more basic
synchronized
keyword. Therefore, both are presented together when we talk about
data synchronization. The same is true of condition variables, which
provide thread notification and are discussed alongside
Java's wait( ) and
notify( ) methods, and of queues, which are
discussed along with Java's other collection
classes.
- Important thread utilities
-
At some point in time, virtually all developers who write threaded
programs will need to use basic thread
utilities such as
a pool or a scheduler; many of them will also need to use advanced
synchronization primitives. A recognition of this fact is one thing
that drove JSR-166梚t was certainly possible in previous
versions of Java to develop your own thread pools and schedulers. But
given the importance of threading in the Java platform, adding these
basic utilities greatly increases programmer productivity.
- Minimal synchronization utilities
-
Java's new atomic classes provide a means by which
developers can, when necessary, write applications that avoid
synchronization.
This can lead to programs that are highly concurrent.
If you've read previous editions of this book, the
concepts presented in the first two categories will be familiar. In
previous editions, we developed our own data synchronization classes,
thread pools, and so on. In those editions, we explained in detail
how our implementations worked and then used them in several
examples. In this edition, we focus solely on how to use these
classes effectively.
The information that falls into the third category is completely new
to this edition. The classes that perform minimal synchronization
require new support from the virtual machine itself and could not be
developed independent of those changes.
|
