A class useful for offloading waiting and signalling operations
on single short variables.
| Method from EDU.oswego.cs.dl.util.concurrent.WaitableShort Detail: |
|---|
 public short add(short amount) {
synchronized (lock_) {
lock_.notifyAll();
return super.add(amount);
}
}
|
public short and(short b) {
synchronized (lock_) {
value_ = (short)(value_ & b);
lock_.notifyAll();
return value_;
}
} |
public boolean commit(short assumedValue,
short newValue) {
synchronized (lock_) {
boolean success = super.commit(assumedValue, newValue);
if (success) lock_.notifyAll();
return success;
}
} |
public short complement() {
synchronized (lock_) {
value_ = (short)(~value_);
lock_.notifyAll();
return value_;
}
} Set the value to its complement |
public short decrement() {
synchronized (lock_) {
lock_.notifyAll();
return super.decrement();
}
} |
public short divide(short factor) {
synchronized (lock_) {
lock_.notifyAll();
return super.divide(factor);
}
} |
public short increment() {
synchronized (lock_) {
lock_.notifyAll();
return super.increment();
}
} |
public short multiply(short factor) {
synchronized (lock_) {
lock_.notifyAll();
return super.multiply(factor);
}
} |
public short or(short b) {
synchronized (lock_) {
value_ = (short)(value_ | b);
lock_.notifyAll();
return value_;
}
} |
public short set(short newValue) {
synchronized (lock_) {
lock_.notifyAll();
return super.set(newValue);
}
} |
public short subtract(short amount) {
synchronized (lock_) {
lock_.notifyAll();
return super.subtract(amount);
}
} |
public void whenEqual(short c,
Runnable action) throws InterruptedException {
synchronized(lock_) {
while (!(value_ == c)) lock_.wait();
if (action != null) action.run();
}
} Wait until value equals c, then run action if nonnull.
The action is run with the synchronization lock held.
* |
public void whenGreater(short c,
Runnable action) throws InterruptedException {
synchronized (lock_) {
while (!(value_ > c)) lock_.wait();
if (action != null) action.run();
}
} wait until value greater than c, then run action if nonnull.
The action is run with the synchronization lock held.
* |
public void whenGreaterEqual(short c,
Runnable action) throws InterruptedException {
synchronized (lock_) {
while (!(value_ >= c)) lock_.wait();
if (action != null) action.run();
}
} wait until value greater than or equal to c, then run action if nonnull.
The action is run with the synchronization lock held.
* |
public void whenLess(short c,
Runnable action) throws InterruptedException {
synchronized (lock_) {
while (!(value_ < c)) lock_.wait();
if (action != null) action.run();
}
} wait until value less than c, then run action if nonnull.
The action is run with the synchronization lock held.
* |
public void whenLessEqual(short c,
Runnable action) throws InterruptedException {
synchronized (lock_) {
while (!(value_ < = c)) lock_.wait();
if (action != null) action.run();
}
} wait until value less than or equal to c, then run action if nonnull.
The action is run with the synchronization lock held.
* |
public void whenNotEqual(short c,
Runnable action) throws InterruptedException {
synchronized (lock_) {
while (!(value_ != c)) lock_.wait();
if (action != null) action.run();
}
} wait until value not equal to c, then run action if nonnull.
The action is run with the synchronization lock held.
* |
public short xor(short b) {
synchronized (lock_) {
value_ = (short)(value_ ^ b);
lock_.notifyAll();
return value_;
}
} |
EDU.oswego.cs.dl.util.concurrent.SynchronizedVariable