// Notifies all the threads waiting on the object.
protected final void notifyAll(Component host_, Object o_) {
if (o_ == null) return;
String old_ = state;
setState(State_NOTIFYING);
// sleepOn = o_;
LockPack p_ = lookforLock(host_, o_);
synchronized (o_) {
// setState(State_NOTIFYING2);
// sleepOn = null;
if (p_.waitCount == 0) return;
// runtime._notifyMany(o_, p_.waitCount, this);
synchronized (aruntime) {
if (aruntime.getWorkforce(p_.waitCount)) {
o_.notifyAll(); // dont know who's going to wake up
aruntime.nthreadsWaiting -= p_.waitCount;
} else {
int remainingWorkforce_ = aruntime.getRemainingWorkforce();
// notify "remainingWorkforce_" threads
for (int i = 0; i < remainingWorkforce_; i++) o_.notify();
aruntime.nthreadsWaiting -= remainingWorkforce_;
for (int i = p_.waitCount - remainingWorkforce_; i > 0; i--)
aruntime.newTask(Task.createNotify(o_), this);
}
}
p_.waitCount = 0;
}
setState(old_);
}
protected final void releaseAllLocks(Component host_) {
String old_ = state;
setState(State_UNLOCKING);
for (LockPack p_ = (LockPack) host_.locks; p_ != null; p_ = p_.next)
if (p_.holder == this) {
// unlock(host_, p_.target, true);
// below is copied from unlock()
synchronized (p_) {
p_.holder = null;
p_.counter = -1;
// p_.counter is not zero, see Note 1 above
if (p_.lockReqCount == 0) {
continue;
}
p_.lockReqCount--;
synchronized (aruntime) {
if (aruntime.getWorkforce()) {
p_.notify(); // dont know who's going to wake up
aruntime.nthreadsWaiting--;
} else aruntime.newTask(Task.createNotify(p_), this);
}
}
}
setState(old_);
}
protected void unlock(Component host_, Object o_, boolean release_) {
LockPack p_ = lookforLock(host_, o_);
String old_ = state;
setState(State_UNLOCKING);
synchronized (p_) {
if (release_ || --p_.counter < 0) p_.counter = 0;
if (p_.counter == 0) {
if (p_.lockReqCount == 0) {
p_.holder = null;
return;
}
// Note 1:
// what if another thread grabs the lock before
// the one being notified below?
// p_.counter is not zero so other threads cannot just grab it
p_.lockReqCount--;
p_.counter = -1;
p_.holder = null;
synchronized (aruntime) {
if (aruntime.getWorkforce()) {
p_.notify(); // dont know who's going to wake up
aruntime.nthreadsWaiting--;
} else {
aruntime.newTask(Task.createNotify(p_), this);
}
}
// ---
}
}
setState(old_);
}
// Make thread wait on the object until being notified by another thread.
protected final void wait(Component host_, Object o_) {
// if (nextTask != null) _semanticsError("wait(Object)");
// looking for LockPack in host
LockPack p_ = lookforLock(host_, o_);
String old_ = state;
setState(State_WAITING);
synchronized (o_) {
// Records the status if the thread holds the lock.
if (waitPack == null) waitPack = new WaitPack();
waitPack.target = p_.target;
if (p_.holder == this) {
waitPack.counter = p_.counter;
// unlock(host_, o_, true/* release all grabs */);
// below is copied from unlock()
synchronized (p_) {
p_.holder = null;
if (p_.lockReqCount == 0) p_.counter = 0;
else {
p_.counter = -1;
// p_.counter is not zero, see Note 1 above
p_.lockReqCount--;
synchronized (aruntime) {
if (aruntime.getWorkforce()) {
p_.notify(); // dont know who's going to wake up
aruntime.nthreadsWaiting--;
} else aruntime.newTask(Task.createNotify(p_), this);
}
}
}
}
p_.waitCount++;
// waited to be notified
_sleepOn(o_, State_WAITING, null);
if (isOrphan()) throw new WorkerThreadInterruptedException("Orphan thread");
// _awakened();
// re-grabbing the lock if necessary.
if (waitPack.counter > 0) {
synchronized (p_) {
if (p_.holder != null) lock(host_, p_.target);
else {
p_.holder = this;
p_.counter = waitPack.counter;
}
}
}
}
if (p_ != null) {
waitPack.counter = 0;
waitPack.target = null;
}
}
/**
* Returns the thread that is holding the lock of the target object. The returned thread may be an
* orphan thread from previous run. final WorkerThread getHolder(Object o_) { Component host_ =
* getHost(); if (host_ == null) return null; LockPack p_ = lookforLock(host_, o_); return p_ ==
* null? null: p_.holder; }
*/
protected void yieldToRuntime() {
synchronized (this) { // avoid racing with runtime.stop()
if (aruntime.isSuspend())
// go into sleep if runtime is suspended
__sleepOn(this, State_PREACTIVE, state);
else if (runtime.resetting) throw new WorkerThreadInterruptedException();
aruntime.newTask(Task.createNotify(this), this);
_sleepOn(this, State_YIELD, null);
}
}
// Notifies the first thread waiting on the object.
protected final void notify(Component host_, Object o_) {
if (o_ == null) return;
String old_ = state;
setState(State_NOTIFYING);
// sleepOn = o_;
LockPack p_ = lookforLock(host_, o_);
synchronized (o_) {
// setState(State_NOTIFYING2);
// sleepOn = null;
if (p_.waitCount == 0) return;
p_.waitCount--;
synchronized (aruntime) {
if (aruntime.getWorkforce()) {
o_.notify(); // dont know who's going to wake up
aruntime.nthreadsWaiting--;
} else {
aruntime.newTask(Task.createNotify(o_), this);
}
}
}
setState(old_);
}
