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

			c.releaseLock(state)
			return
		}
	}
}

func (c *Counter) releaseReader(state counterStateBits) {
	for ; ; state = c.state.load() {
		// If we are the last reader and havePtr was cleared
		// while this batch of readers was using c.ptr,
		// it's our job to update c.ptr by upgrading to a full lock
		// and letting releaseLock do the work.

    }

    @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) {

                    }
                    return supplier.calculateValue(effectiveContext);
                });
                owner.calculationState = null;
            } finally {
                releaseLock();
            }
        }

        private void acquireLock() {
            if (lock.tryLock()) {
                // Lock not contended - can proceed
                return;
            }

                            resourceLockState.releaseLocks();
                            return false;
                        default:
                            throw new IllegalArgumentException("Unhandled disposition type: " + disposition.name());
                    }
                }
            } catch (Throwable t) {
                resourceLockState.releaseLocks();

    }

    @Override
    public void runAsIsolatedTask() {
        Registries registries = this.registries.get();
        releaseLocks(registries.getProjectLockRegistry().getResourceLocksByCurrentThread());
        releaseLocks(registries.getTaskExecutionLockRegistry().getResourceLocksByCurrentThread());
    }

    @Override
    public void runAsIsolatedTask(Runnable runnable) {

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

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