Java 并发核心编程原文+译文

of actions like reading and writing fields, and synchronizing on a monitor.

These actions form an ordering (called the “happens-before” ordering)

that can be used to reason about when a thread sees the result of another

thread’s actions, what constitutes a properly synchronized program, how to

make fields immutable, and more.

In Java, every object contains a “monitor” that can be used to provide

mutual exlusion access to critical sections of code. The critical section is

specified by marking a method or code block as synchronized. Only

one thread at a time is allowed to execute any critical section of code for a

Assigning a value to a field is an atomic action for all types except doubles

and longs. Doubles and longs are allowed to be updated as two separate

operations by a JVM implementation so another thread might theoretically

see a partial update. To protect updates of shared doubles and longs,

mark the field as a volatile or modify it in a synchronized block.

A race condition occurs when more than one thread is performing a series

of actions on shared resources and several possible outcomes can exist

based on the order of the actions from each thread are performed.

It is unsafe to publish a reference to an object before construction of the

object is complete. One way that the this reference can escape is by

registering a listener with a callback during construction. Another common

scenario is starting a Thread from the constructor. In both cases, the

partially constructed object is visible to other threads.

Final fields must be set to an explicit value by the end of object

construction or the compiler will emit an error. Once set, final field values

cannot be changed. Marking an object reference field as final does