Re: Speaking of thread safety?
On 3/10/2010 10:01 PM, markspace wrote:
Knute Johnson wrote:
On 3/10/2010 8:48 PM, Peter Duniho wrote:
If the mutable Object was thread-safe, then it would handle that.
Otherwise, you'd have to use some mechanism for ensuring
synchronization. As far as I know, Java doesn't have an explicit memory
barrier API, so "synchronized" is probably the best approach for simple
mutation observability issues.
Pete
And there's the rub. If you have as in my case, two separate classes,
where you don't want to share data other than that which is shared via
the Observable/Observer, how do you get the Observable instance in the
Observer to then use to synchronize with? You have to assume that a
different thread could read the data after it was stored via the
Observer.update() method.
What are you trying to do? Are you trying to pass data between threads,
or are you actually trying to implement an Observer Pattern?
If you're implementing an Observer, you should probably take care to
synchronize yourself, since the Observer really doesn't guarantee
synchronization.
If you're just looking for a memory barrier API, I think several classes
in java.util.concurrent guarantee synchronization explicitly. This
includes lock objects, executors, concurrent collections and probably a
few others. This might be as simple as dumping the data into a
BlockingQueue, and then reading it with a different thread.
It would seem that there should be some method simpler than having to
create a BlockingQueue to hand data between the Observable and the Observer.
I have two classes that happen to be extensions of JPanels. Both of
them have methods to input data that is then displayed (in various
forms) on the other. The Observable/Observer appeared to be perfectly
suited for this purpose. Then I got to thinking about which thread was
being used and the fact that different threads could be writing/reading
the data. That caused me to try to figure out how to synchronize that
data between the classes. In my actual app, I write the data to a
volatile int and that I'm sure will work but what if I needed to pass a
reference to mutable object and wanted to ensure that the Observer had
the latest information.
So I'm sure the BlockingQueue would work but doesn't there have to be a
simpler way? Or have I just designed this in a way that it was never
intended to be?
Thanks,
--
Knute Johnson
email s/nospam/knute2010/