为什么Observable类中的方法是同步的？

Question

Why are the methods in the Observable class are synchronized?

public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

Answer 1

Observable is intended to be a very thread-safe class; it manipulates shared data 'atomically', meaning that only one thread can access it at a time. The synchronized keyword forces each interacting thread to access the Observable instance's data atomically.

synchronized methods enable a simple strategy for preventing thread interference and memory consistency errors: if an object is visible to more than one thread, all reads or writes to that object's variables are done through synchronized methods.

Note that some methods, such as notifyObservers() , are not synchronized . This is because they do not directly affect the instance data of the Observable .

Read this writeup if you want to learn more about thread-safety.

Answer 2

I can't give you a definitive answer regarding why Observable is implemented the way it is, but I can explain the effect.

While Vector is a synchronized collection, it isn't synchronized while iterating . This is similar to the wrappers returned by the Collections.synchronizedXXX methods. In order to safely iterate a Vector in a concurrent context you need external synchronization. They accomplish this by using synchronized methods. But if you look at notifyObservers you'll see that the method isn't synchronized. However, if you look at the body of notifyObservers you'll see a synchronized(this) {} block. They do it this way because only part of the method body needs to be executed while holding the lock. If you're not aware, a synchronized instance method is the same as using synchronized(this) {} for the whole method.

The other effect caused by using synchronized methods is that both the obs field and the changed field are guarded by the same lock. This keeps the state between those two fields consistent in a multi-threaded environment. Why they chose the enclosing instance as the lock, I have no idea, but that's what they did.

Note that, as near as I can tell, the Observable class gives no guarantees regarding thread-safety in its documentation. This means the fact that it is thread-safe is an implementation detail.

Also note that Observable has been deprecated since Java 9.