* notify threads waiting on a lock.
     */
    void registerUnlocked(ResourceLock resourceLock);

    /**
     * Release any locks that have been acquired during the transform.
     */
    void releaseLocks();

                try {
                    owner.lockAcquired(this);
                } catch (RuntimeException e) {
                    releaseLock();
                    throw e;
                }
                coordinationService.getCurrent().registerLocked(this);
                return true;
            } else {
                return false;
            }

    }

    @Override
    protected boolean canAcquire() {
        return stateLock.isLockedByCurrentThread() || stateLock.tryLock();
    }

    @Override
    protected void releaseLock() {
        super.releaseLock();
        stateLock.unlock();
    }

    protected boolean acquireLock() {
        if (parent.grantLease()) {
            ownerThread = Thread.currentThread();
        }
        return ownerThread != null;
    }

    @Override
    protected void releaseLock() {
        if (Thread.currentThread() != ownerThread) {
            // Not implemented - not yet required. Please implement if required

            owner = currentThread;
            return true;
        }
        return false;
    }

    protected boolean canAcquire() {
        return true;
    }

    @Override
    protected void releaseLock() {
        owner = null;
    }

    @Override
    protected boolean doIsLockedByCurrentThread() {
        return owner == Thread.currentThread();
    }

    @Override

            owner.set(Thread.currentThread())
            lockedState.set(true)
            return true
        } else {
            return false
        }
    }

    @Override
    protected void releaseLock() {
        owner.set(null)
        lockedState.set(false)
    }

    boolean getLockedState() {
        return lockedState.get()
    }

    void setLockedState(boolean lockedState) {