While
creating synchronized methods within classes that you create is an easy and
Effective
means of achieving synchronization, it will not work in all cases. To
understand why, consider the following. Imagine that you want to synchronize
access to objects of a class that was not designed for multithreaded access.
That is, the class does not use synchronized methods. Further, this class was
not created by you, but by a third party, and you do not have access to the
source code. Thus, you can’t add synchronized to the appropriate methods within
the class. How can access to an object of this class be synchronized?
Fortunately, the solution to this problem is quite easy: You simply put calls
to the methods defined by this class inside a synchronized block.
This
is the general form of the synchronized statement:
synchronized(object)
{
//
statements to be synchronized
}
Here,
object is a reference to the object being synchronized. A synchronized block
ensures
that a call to a method that is a member of object occurs only after the
current thread has successfully entered object’s monitor.
