} finally {
            releaseOwnership(previous);
        }
    }

    private Thread takeOwnership() {
        final Thread currentThread = Thread.currentThread();
        if (!workerLeaseService.isWorkerThread()) {
            throw new IllegalStateException("The current thread is not registered as a worker thread.");
        }
        synchronized (this) {
            if (owner == null) {
                owner = currentThread;

            }

            @Override
            <T> T withLock(Factory<T> action) {
                return action.create()
            }
        }
    }

    @Override
    boolean isWorkerThread() {
        return true
    }

    @Override
    void runAsIsolatedTask(Runnable runnable) {
        runnable.run()
    }

    @Override
    <T> T runAsIsolatedTask(Factory<T> action) {

     */
    WorkerLeaseRegistry.WorkerLeaseCompletion maybeStartWorker();

    /**
     * Returns {@code true} when this thread is enlisted in resource locking.
     */
    boolean isWorkerThread();

        build.ensureProjectsLoaded();
        return build.getProjects().getProject(Path.path(projectIdentity.getProjectPath()));
    }

    private void assertCanQuery() {
        if (!workerThreadRegistry.isWorkerThread()) {
            throw new IllegalStateException("A build controller cannot be used from a thread that is not managed by Gradle.");
        }
    }

    @Override
    public void dispatch(Object value) {

        asyncWorkTracker.registerWork(currentBuildOperation, execution);
        return execution;
    }

    private void checkIsManagedThread() {
        if (!workerThreadRegistry.isWorkerThread()) {
            throw new IllegalStateException("An attempt was made to submit work from a thread not managed by Gradle.  Work may only be submitted from a Gradle-managed thread.");
        }
    }

    /**

    }

    @Override
    public DefaultWorkerLease newWorkerLease() {
        return workerLeaseLockRegistry.newResourceLock();
    }

    @Override
    public boolean isWorkerThread() {
        return workerLeaseLockRegistry.holdsLock();
    }

    @Override
    public <T> T runAsWorkerThread(Factory<T> action) {

            return currentState.get();
        }

        ResolverResults newState;
        if (!domainObjectContext.getModel().hasMutableState()) {
            if (!workerThreadRegistry.isWorkerThread()) {
                // Error if we are executing in a user-managed thread.
                throw new IllegalStateException("The configuration " + identityPath.toString() + " was resolved from a thread not managed by Gradle.");