EDU.oswego.cs.dl.util.concurrent: public class: SynchronizedBoolean

EDU.oswego.cs.dl.util.concurrent
public class: SynchronizedBoolean [javadoc | source]

java.lang.Object
   EDU.oswego.cs.dl.util.concurrent.SynchronizedVariable
      EDU.oswego.cs.dl.util.concurrent.SynchronizedBoolean

All Implemented Interfaces:
Cloneable, Comparable, Executor

Direct Known Subclasses:
WaitableBoolean

A class useful for offloading synch for boolean instance variables.

[ Introduction to this package. ]
Field Summary
protected boolean value_
Fields inherited from EDU.oswego.cs.dl.util.concurrent.SynchronizedVariable:
lock_

Constructor:

public SynchronizedBoolean(boolean initialValue)
{ super(); value_ = initialValue; }
Make a new SynchronizedBoolean with the given initial value, and using its own internal lock. *
public SynchronizedBoolean(boolean initialValue, Object lock)
{ super(lock); value_ = initialValue; }
Make a new SynchronizedBoolean with the given initial value, and using the supplied lock. *

Method from EDU.oswego.cs.dl.util.concurrent.SynchronizedBoolean Summary:
and, commit, compareTo, compareTo, compareTo, complement, equals, get, hashCode, or, set, swap, toString, xor
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.SynchronizedBoolean Detail:

public boolean and(boolean b)
{ synchronized (lock_) { value_ = value_ & b; return value_; } }
Set value to value & b.
public boolean commit(boolean assumedValue, boolean newValue)
{ synchronized(lock_) { boolean success = (assumedValue == value_); if (success) value_ = newValue; return success; } }
Set value to newValue only if it is currently assumedValue.
public int compareTo(boolean other)
{ boolean val = get(); return (val == other)? 0 : (val)? 1 : -1; }
public int compareTo(SynchronizedBoolean other)
{ return compareTo(other.get()); }
public int compareTo(Object other)
{ return compareTo((SynchronizedBoolean)other); }
public boolean complement()
{ synchronized (lock_) { value_ = !value_; return value_; } }
Set the value to its complement
public boolean equals(Object other)
{ if (other != null && other instanceof SynchronizedBoolean) return get() == ((SynchronizedBoolean)other).get(); else return false; }
public final boolean get()
{ synchronized(lock_) { return value_; } }
Return the current value
public int hashCode()
{ boolean b = get(); return (b)? 3412688 : 8319343; // entirely arbitrary }
public boolean or(boolean b)
{ synchronized (lock_) { value_ = value_ | b; return value_; } }
Set value to value | b.
public boolean set(boolean newValue)
{ synchronized (lock_) { boolean old = value_; value_ = newValue; return old; } }
Set to newValue.
public boolean swap(SynchronizedBoolean other)
{ if (other == this) return get(); SynchronizedBoolean fst = this; SynchronizedBoolean 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 SynchronizedBoolean. Uses identityHashCode to avoid deadlock when two SynchronizedBooleans 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.)
public String toString()
{ return String.valueOf(get()); }
public boolean xor(boolean b)
{ synchronized (lock_) { value_ = value_ ^ b; return value_; } }
Set value to value ^ b.