Chapter 5. Minimal Synchronization Techniques
In the previous two chapters, we discussed ways of making objects
threadsafe, allowing them to be used by two or more threads at the
same time. Thread safety is the most important aspect of good thread
programming; race conditions are extremely difficult to reproduce and
fix.
In this chapter, we complete our discussion of data synchronization
and thread safety by examining two related topics. We begin with a
discussion of the Java memory model, which defines how variables are
actually accessed by threads. This model has some surprising
ramifications; one of the issues that we'll clear up
from our previous chapters is just what it means for a thread to be
modeled as a list of instructions. After explaining the memory model,
we discuss how volatile variables fit into it and why they can be
used safely among multiple threads. This topic is all about avoiding
synchronization.
We then examine another approach to data synchronization: the use of
atomic classes. This set of classes, introduced in J2SE 5.0, allows
certain operations on certain types of data to be defined atomically.
These classes provide a nice data abstraction for the operations
while preventing the race conditions that would otherwise be
associated with the operation. These classes are also interesting
because they take a different approach to synchronization: rather
than explicitly synchronizing access to the data, they use an
approach that allows race conditions to occur but ensures that the
race conditions are all benign. Therefore, these classes
automatically avoid explicit synchronization.
| 
