| Method from EDU.oswego.cs.dl.util.concurrent.SynchronizedShort Detail: |
|---|
 public short add(short amount) {
synchronized (lock_) {
return value_ += amount;
}
}
Add amount to value (i.e., set value += amount) |
public short and(short b) {
synchronized (lock_) {
value_ = (short)(value_ & b);
return value_;
}
} |
public boolean commit(short assumedValue,
short 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(short other) {
short val = get();
return (val < other)? -1 : (val == other)? 0 : 1;
} |
public int compareTo(SynchronizedShort other) {
return compareTo(other.get());
} |
public int compareTo(Object other) {
return compareTo((SynchronizedShort)other);
} |
public short complement() {
synchronized (lock_) {
value_ = (short)(~value_);
return value_;
}
} Set the value to its complement |
public short decrement() {
synchronized (lock_) {
return --value_;
}
} |
public short divide(short factor) {
synchronized (lock_) {
return value_ /= factor;
}
} Divide value by factor (i.e., set value /= factor) |
public boolean equals(Object other) {
if (other != null &&
other instanceof SynchronizedShort)
return get() == ((SynchronizedShort)other).get();
else
return false;
} |
public final short get() {
synchronized(lock_) { return value_; }
} |
public int hashCode() {
return (int)(get());
} |
public short increment() {
synchronized (lock_) {
return ++value_;
}
} |
public short multiply(short factor) {
synchronized (lock_) {
return value_ *= factor;
}
} Multiply value by factor (i.e., set value *= factor) |
public short negate() {
synchronized (lock_) {
value_ = (short)(-value_);
return value_;
}
} Set the value to the negative of its old value |
public short or(short b) {
synchronized (lock_) {
value_ = (short)(value_ | b);
return value_;
}
} |
public short set(short newValue) {
synchronized (lock_) {
short old = value_;
value_ = newValue;
return old;
}
} |
public short subtract(short amount) {
synchronized (lock_) {
return value_ -= amount;
}
} Subtract amount from value (i.e., set value -= amount) |
public short swap(SynchronizedShort other) {
if (other == this) return get();
SynchronizedShort fst = this;
SynchronizedShort 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 SynchronizedShort.
Uses identityHashCode to avoid deadlock when
two SynchronizedShorts 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 short xor(short b) {
synchronized (lock_) {
value_ = (short)(value_ ^ b);
return value_;
}
} |
EDU.oswego.cs.dl.util.concurrent.SynchronizedVariable