EDU.oswego.cs.dl.util.concurrent
public class: SynchronizedRef [javadoc |
source]
java.lang.Object
EDU.oswego.cs.dl.util.concurrent.SynchronizedVariable
EDU.oswego.cs.dl.util.concurrent.SynchronizedRef
All Implemented Interfaces:
Executor
Direct Known Subclasses:
WaitableRef
A simple class maintaining a single reference variable that
is always accessed and updated under synchronization.
[ Introduction to this package. ]
| Field Summary |
|---|
| protected Object | value_ | The maintained reference |
| Constructor: |
|---|
 public SynchronizedRef(Object initialValue) {
super();
value_ = initialValue;
}
Create a SynchronizedRef initially holding the given reference
and using its own internal lock. |
public SynchronizedRef(Object initialValue,
Object lock) {
super(lock);
value_ = initialValue;
} Make a new SynchronizedRef with the given initial value,
and using the supplied lock.
* |
| Method from EDU.oswego.cs.dl.util.concurrent.SynchronizedRef Summary: |
|---|
|
commit, get, set, swap |
| Methods from EDU.oswego.cs.dl.util.concurrent.SynchronizedVariable: |
|---|
|
execute, getLock |
| Methods from java.lang.Object: |
|---|
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Method from EDU.oswego.cs.dl.util.concurrent.SynchronizedRef Detail: |
|---|
public boolean commit(Object assumedValue,
Object newValue) {
synchronized(lock_) {
boolean success = (assumedValue == value_);
if (success) value_ = newValue;
return success;
}
} Set value to newValue only if it is currently assumedValue. |
public final Object get() {
synchronized(lock_) { return value_; }
} |
public Object set(Object newValue) {
synchronized (lock_) {
Object old = value_;
value_ = newValue;
return old;
}
} |
public Object swap(SynchronizedRef other) {
if (other == this) return get();
SynchronizedRef fst = this;
SynchronizedRef snd = other;
if (System.identityHashCode(fst) > System.identityHashCode(snd)) {
fst = other;
snd = this;
}
synchronized(fst.lock_) {
synchronized(snd.lock_) {
fst.set(snd.set(fst.get()));
return get();
}
}
} Atomically swap values with another SynchronizedRef.
Uses identityHashCode to avoid deadlock when
two SynchronizedRefs attempt to simultaneously swap with each other.
(Note: Ordering via identyHashCode is not strictly guaranteed
by the language specification to return unique, orderable
values, but in practice JVMs rely on them being unique.) |