The lock mode can be controlled from the `dependencyLocking` block as shown below:

.Setting the lock mode
====
include::sample[dir="snippets/dependencyManagement/dependencyLocking-lockModeSelection/kotlin",files="build.gradle.kts[tags=lock-mode]"]
include::sample[dir="snippets/dependencyManagement/dependencyLocking-lockModeSelection/groovy",files="build.gradle[tags=lock-mode]"]
====

        }

        override fun dependencyLocking(configuration: Action<in DependencyLockingHandler>) {
            onAccess("dependencyLocking")
            delegate.dependencyLocking(configuration)
        }

        override fun getDependencyLocking(): DependencyLockingHandler {
            onAccess("dependencyLocking")
            return delegate.dependencyLocking
        }

        delegate.createAntBuilder()

    override fun getObjects(): ObjectFactory =
        delegate.objects

    override fun dependencyLocking(configuration: Action<in DependencyLockingHandler>) =
        delegate.dependencyLocking(configuration)

    override fun tarTree(tarPath: Any): FileTree =
        delegate.tarTree(tarPath)

    override fun delete(vararg paths: Any?): Boolean =

        DefaultExternalModuleDependency       | Dependency                     | "project.dependencies.create('junit:junit:4.13')"
        DefaultDependencyLockingHandler       | DependencyLockingHandler       | "project.dependencyLocking"

        mavenRepo.module('org', 'foo', '1.0').publish()
        mavenRepo.module('org', 'foo', '1.1').publish()

        buildFile << """
dependencyLocking {
    lockAllConfigurations()
}

repositories {
    maven {
        name 'repo'
        url '${mavenRepo.uri}'
    }
}
configurations {
    lockedConf
}

dependencies {

        configuration.execute(getNormalization());
    }

    @Inject
    @Override
    public abstract DependencyLockingHandler getDependencyLocking();

    @Override
    public void dependencyLocking(Action<? super DependencyLockingHandler> configuration) {
        configuration.execute(getDependencyLocking());
    }

    @Override

Method <org.gradle.api.initialization.dsl.ScriptHandler.dependencyLocking(groovy.lang.Closure)> has arguments/return type groovy.lang.Closure that is not Gradle public API or primitive or built-in JDK classes or Kotlin classes in (ScriptHandler.java:0)

     */
    void normalization(Action<? super InputNormalizationHandler> configuration);

    /**
     * Configures dependency locking
     *
     * @since 4.8
     */
    void dependencyLocking(Action<? super DependencyLockingHandler> configuration);

    /**
     * Provides access to configuring dependency locking
     *
     * @since 4.8
     */

import java.util.List;
import java.util.Map;
import java.util.Set;

public class ResolutionResultGraphBuilder implements ResolvedComponentVisitor {
    private static final DefaultComponentSelectionDescriptor DEPENDENCY_LOCKING = new DefaultComponentSelectionDescriptor(ComponentSelectionCause.CONSTRAINT, Describables.of("Dependency locking"));
    private final Long2ObjectMap<DefaultResolvedComponentResult> components = new Long2ObjectOpenHashMap<>();

`--write-locks`::
Indicates that all resolved configurations that are _lockable_ should have their <<dependency_locking.adoc#dependency-locking,lock state>> persisted.

`--update-locks <group:name>[,<group:name>]*`::
Indicates that versions for the specified modules have to be updated in the <<dependency_locking.adoc#dependency-locking,lock file>>.
+
This flag also implies `--write-locks`.

`-a`, `--no-rebuild`::