public String toString() {
        return getClass().getSimpleName() + " " + getDisplayName();
    }

    @Override
    public boolean tryLock() {
        if (!isLockedByCurrentThread()) {
            if (acquireLock()) {
                LOGGER.debug("{}: acquired lock on {}", Thread.currentThread().getName(), displayName);
                try {
                    owner.lockAcquired(this);
                } catch (RuntimeException e) {

        return ownerThread != null;
    }

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

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

    @Override
    protected void releaseLock() {

        super(displayName, coordinationService, owner);
    }

    @Override
    protected boolean acquireLock() {
        Thread currentThread = Thread.currentThread();
        if (owner == currentThread) {
            return true;
        }
        if (owner == null && canAcquire()) {
            owner = currentThread;

        return lockedState.get()
    }

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

    @Override
    protected boolean acquireLock() {
        if (!lockedState.get()) {
            owner.set(Thread.currentThread())
            lockedState.set(true)
            return true
        } else {
            return false
        }
    }

            this.defaultContext = defaultContext;
        }

        // Can be called multiple times
        void attachValue(CalculatedValueContainer<T, ?> owner, @Nullable NodeExecutionContext context) {
            acquireLock();
            try {
                if (done) {
                    // Already calculated
                    return;
                }
                done = true;

      for (LockGraphNode acquiredLock : acquiredLocks) {
        checkAcquiredLock(policy, acquiredLock);
      }
    }

    /**
     * Checks the acquisition-ordering between {@code this}, which is about to be acquired, and the
     * specified {@code acquiredLock}.
     *
     * <p>When this method returns, the {@code acquiredLock} should be in either the {@code

      for (LockGraphNode acquiredLock : acquiredLocks) {
        checkAcquiredLock(policy, acquiredLock);
      }
    }

    /**
     * Checks the acquisition-ordering between {@code this}, which is about to be acquired, and the
     * specified {@code acquiredLock}.
     *
     * <p>When this method returns, the {@code acquiredLock} should be in either the {@code

        return unlock(Arrays.asList(resourceLocks));
    }

    private static class AcquireLocks implements InternalTransformer<ResourceLockState.Disposition, ResourceLockState> {
        private final Iterable<? extends ResourceLock> resourceLocks;
        private final boolean blocking;

        AcquireLocks(Iterable<? extends ResourceLock> resourceLocks, boolean blocking) {
            this.resourceLocks = resourceLocks;

        }
    }

    private void releaseLocks(Iterable<? extends ResourceLock> locks) {
        coordinationService.withStateLock(unlock(locks));
    }

    private void acquireLocks(final Iterable<? extends ResourceLock> locks) {
        if (containsProjectLocks(locks)) {
            projectLockStatistics.measure(new Runnable() {
                @Override
                public void run() {

private long timeout; private java.util.Map currentLockCounters; protected void FileBasedLockStrateg(); protected void FileBasedLockStrateg(boolean); private void FileBasedLockStrateg(FileBasedLockStrateg$FileLocker, boolean); protected final boolean acquireLock(java.io.File); protected final void releaseLock(java.io.File); private static void debugLocking(String); private int incrementLock(java.io.File); } org/apache/ivy/plugins/lock/FileBasedLockStrateg$FileLocker.class package org.apache.ivy.plugins.lock;...