Composing Objects - Java Concurrency in Practice - page 62

Chapter 4. Composing Objects

So far, we've covered the low-level basics of thread safety and synchronization. But we don't
want to have to analyze each memory access to ensure that our program is thread-safe; we
want to be able to take thread-safe components and safely compose them into larger compon-
ents or programs. This chapter covers patterns for structuring classes that can make it easier
to make them thread-safe and to maintain them without accidentally undermining their safety
guarantees.

4.1. Designing a Thread-safe Class

While it is possible to write a thread-safe program that stores all its state in public static fields,
it is a lot harder to verify its thread safety or to modify it so that it remains thread-safe than
one that uses encapsulation appropriately. Encapsulation makes it possible to determine that a
class is thread-safe without having to examine the entire program.

The design process for a thread-safe class should include these three basic elements:
• Identify the variables that form the object's state;

• Identify the invariants that constrain the state variables;

• Establish a policy for managing concurrent access to the object's state.

An object's state starts with its fields. If they are all of primitive type, the fields comprise the
entire state. Counter in Listing 4.1 has only one field, so the value field comprises its en-
tire state. The state of an object with n primitive fields is just the n -tuple of its field values;
the state of a 2D Point is its ( x , y ) value. If the object has fields that are references to other
objects, its state will encompass fields from the referenced objects as well. For example, the
state of a LinkedList includes the state of all the link node objects belonging to the list.

The synchronization policy defines how an object coordinates access to its state without vi-
olating its invariants or postconditions. It specifies what combination of immutability, thread
confinement, and locking is used to maintain thread safety, and which variables are guarded
by which locks. To ensure that the class can be analyzed and maintained, document the syn-
chronization policy.

Listing 4.1. Simple Thread-safe Counter Using the Java Monitor Pattern.