Class WaitLock

  • public class WaitLock
    extends java.lang.Object
    A simple lock used to implement load-on-demand mechanism. Typical use: a thread, say A, checks whether a resource is loaded, and put a WaitLock instance if not loaded yet. Then, another thread, say B, if find WaitLock, it simply calls waitUntilUnlock(int) to wait. Meanwhile, once A completes the loading, it put back the resource and calls unlock().
    WaitLock lock = null;
    for (;;) {
            synchronized (map) {
                    Object o = map.get(key);
                    if (o == null) {
                            map.put(key, lock = new WaitLock());
                            break; //go to load resource
            if (o instanceof MyResource)
                    return (MyResource)o;
            if (!((Lock)o).waitUntilUnlock(60000))
                    log.waring("Takes too long");
    //load resource
    try {
            synchronized (map) {
                    map.put(key, resource);
            return resource;
    } catch (Throwable ex) {
            synchronized (map) {
            throw SystemException.Aide.wrap(ex);
    } finally {
    • Constructor Summary

      Constructor Description
      Once created, it is default to be locked.
    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void unlock()
      Unlocks any other threads blocked by waitUntilUnlock(int).
      boolean waitUntilUnlock​(int timeout)
      Waits this lock to unlock.
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Constructor Detail

      • WaitLock

        public WaitLock()
        Once created, it is default to be locked. In other words, other thread's invocation of waitUntilUnlock(int) won't return until unlock() is called.
    • Method Detail

      • waitUntilUnlock

        public boolean waitUntilUnlock​(int timeout)
        Waits this lock to unlock.
        whether it is unlocked successfully
        SystemException - if this thread is interrupted
        PotentialDeadLockException - if the thread itself creates this lock. In other words, it tried to wait for itself to complete.