Я думаю, вы говорите о мьютексе (или взаимных исключающих блокировках).Если это так, вы можете использовать встроенные замки.Этот тип блокировок в Java действует как мьютексы, что означает, что блокировка может принадлежать не одному потоку:
synchronized (lock) {
// Access or modify shared state guarded by lock
}
Где блокировка - фиктивный объект, используемый только для блокировки.
РЕДАКТИРОВАТЬ:
Вот реализация для вас - класс блокировки взаимного исключения не реентерабельный, который использует нулевое значение для представления разблокированного состояния и один для представления заблокированного состояния.
class Mutex implements Lock, java.io.Serializable {
// Our internal helper class
private static class Sync extends AbstractQueuedSynchronizer {
// Report whether in locked state
protected boolean isHeldExclusively() {
return getState() == 1;
}
// Acquire the lock if state is zero
public boolean tryAcquire(int acquires) {
assert acquires == 1; // Otherwise unused
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
// Release the lock by setting state to zero
protected boolean tryRelease(int releases) {
assert releases == 1; // Otherwise unused
if (getState() == 0) throw new IllegalMonitorStateException();
setExclusiveOwnerThread(null);
setState(0);
return true;
}
// Provide a Condition
Condition newCondition() { return new ConditionObject(); }
// Deserialize properly
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException {
s.defaultReadObject();
setState(0); // reset to unlocked state
}
}
// The sync object does all the hard work. We just forward to it.
private final Sync sync = new Sync();
public void lock() { sync.acquire(1); }
public boolean tryLock() { return sync.tryAcquire(1); }
public void unlock() { sync.release(1); }
public Condition newCondition() { return sync.newCondition(); }
public boolean isLocked() { return sync.isHeldExclusively(); }
public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
}
Если вам нужно знать, куда следует звонить wait() и notify(), взгляните на sun.misc.Unsafe#park().Он используется в пакете java.util.concurrent.locks (AbstractQueuedSynchronizer <- LockSupport <- Небезопасно). </p>
Надеюсь, это поможет.