On 3/10/2010 8:39 PM, John B. Matthews wrote:
In article<WXWln.10092$QL4.95@newsfe24.iad>,
Knute Johnson<nospam@rabbitbrush.frazmtn.com> wrote:
On 3/10/2010 3:07 PM, John B. Matthews wrote:
In article<S9Sln.90254$Ye4.78776@newsfe11.iad>,
Knute Johnson<nospam@rabbitbrush.frazmtn.com> wrote:
On 3/10/2010 10:34 AM, markspace wrote:
Knute Johnson wrote:
Does anybody know if the Observable/Observer calls to update() are on
the EDT?
Considering that Observer is just an interface and it would
depend on the implementation, and that no Java Swing classes that
I know of actually implement Observer, I'd have to guess the
answer is in general "no."
The Observable class method, notifyObservers() is called and that
then calls all Observer.update() methods. I'm curious to know if
the Observable puts those calls onto the EDT.
As markspace has elaborated, the answer is no. Not long ago, I
proposed that on Observable can invoke notifyObservers() on the
EDT, as via javax.swing.Timer, but access to any data shared
between threads must still be correctly synchronized. I found this
discussion very helpful
<http://groups.google.com/group/comp.lang.java.programmer/browse_frm/thread/4c4a6b46ffd2d31f>
and I have tried to express my understanding in this example:
<http://sites.google.com/site/drjohnbmatthews/threadwatch>
I looked through the source code and all of the methods of Observable
are synchronized on the Observable instance. So threads that read
any argument that is passed in and stored needs to be synchronized as
well. I'm not sure how to do that. The whole point of using
Observer/Observable is to disconnect the two classes.
Interesting. The synchronized block in notifyObservers() mentions two,
worst-case potential races: 1) a newly-added Observer will miss a
notification in progress, and 2) a recently unregistered Observer will
be wrongly notified when it doesn't care. Unfortunately, the API doesn't
mention being synchronized.
Calling notifyObservers() from a known thread could be used to
synchronize via thread containment but the docs imply that the
calling thread isn't necessarily guaranteed to be the writing thread
in the future.
I read the Observable API as "but subclasses [of Observable] may ...
deliver notifications on separate threads."
In the application that I am writing, I am passing an Integer). In
the Observer.update() method I store that Integer. I'm storing it in
a volatile int so that solves the visibility problems for the reading
thread but what if you had a mutable Object to pass?
I'm not sure about that.