package org.gradle.workers;

import org.gradle.api.file.ConfigurableFileCollection;

/**
 * A worker spec providing the requirements of an isolated classpath.
 *
 * @since 5.6
 */
public interface ClassLoaderWorkerSpec extends WorkerSpec {
    /**
     * Gets the classpath associated with the worker.
     *
     * @return the classpath associated with the worker
     */
    ConfigurableFileCollection getClasspath();

import org.gradle.api.file.ConfigurableFileCollection;
import org.gradle.api.model.ObjectFactory;
import org.gradle.workers.ClassLoaderWorkerSpec;

import javax.inject.Inject;

public class DefaultClassLoaderWorkerSpec extends DefaultWorkerSpec implements ClassLoaderWorkerSpec {
    private final ConfigurableFileCollection classpath;

    @Inject
    public DefaultClassLoaderWorkerSpec(ObjectFactory objectFactory) {

import org.gradle.process.JavaForkOptions;
import org.gradle.workers.ClassLoaderWorkerSpec;
import org.gradle.workers.ProcessWorkerSpec;

import javax.inject.Inject;
import java.util.Map;
import java.util.regex.Pattern;

public class DefaultProcessWorkerSpec extends DefaultClassLoaderWorkerSpec implements ProcessWorkerSpec, ClassLoaderWorkerSpec {
    /**
     * Environment variables inherited automatically on Unix systems.

            return new ForkedWorkerRequirement(baseDir, projectCacheDir.getDir(), builder.build());
        } else if (configuration instanceof ClassLoaderWorkerSpec) {
            ClassLoaderWorkerSpec classLoaderConfiguration = (ClassLoaderWorkerSpec) configuration;

----
<1> Expose an input property for the codec library classpath.
<2> Configure the classpath on the link:{javadocPath}/org/gradle/workers/ClassLoaderWorkerSpec.html[ClassLoaderWorkerSpec] when creating the work queue.

Next, you need to configure your build so that it has a repository to look up the codec version at task execution time.

package org.gradle.workers;

/**
 * A worker spec providing the requirements of a forked process with a custom classpath.
 *
 * @since 5.6
 */
public interface ProcessWorkerSpec extends ForkingWorkerSpec, ClassLoaderWorkerSpec {

    /**
     * Creates a {@link WorkQueue} to submit work for asynchronous execution with an isolated classloader and the requirements specified in the supplied {@link ClassLoaderWorkerSpec}.
     *
     * @since 5.6
     */
    WorkQueue classLoaderIsolation(Action<? super ClassLoaderWorkerSpec> action);

    /**
     * Creates a {@link WorkQueue} to submit work for asynchronous execution in a daemon process.
     *

                void executeTask() {
                    workerExecutor."\${isolationMode}"({ spec ->
                        displayName = this.displayName
                        if (spec instanceof ClassLoaderWorkerSpec) {
                            classpath.from(additionalClasspath)
                        }
                        if (spec instanceof ProcessWorkerSpec) {
                            forkOptions.maxHeapSize = "64m"

                            config.forkOptions.maxHeapSize = "64m"
                            config.forkOptions(additionalForkOptions)
                        }
                        if (config instanceof ClassLoaderWorkerSpec) {
                            config.classpath.from(additionalClasspath)
                        }
                        configClosure.call(config)
                    }).submit(actionClass) {

                                        forkOptions(additionalForkOptions)
                                    }
                                    if (config instanceof ClassLoaderWorkerSpec) {
                                        classpath.from(additionalClasspath)
                                    }
                                }).submit(workActionClass) {