// so the key was re-added and may have been shared after the call.
			// Try again with more time to park.
			d *= 2
			continue
		}

		// All of the Do calls ended up sharing the first
		// invocation, so the key should have been unused
		// (and therefore unshared) when they returned.
		if shared.Load() > 0 {
			t.Errorf("after a single shared Do, ForgetUnshared returned false %d times", shared.Load())
		}

        staticLibrary("build/libs/helloStatic/static/helloStatic").assertExistsAndDelete()
        sharedLibrary("build/libs/helloShared/shared/helloShared").assertExistsAndDelete()
        installation("build/install/main")
            .assertIncludesLibraries("helloShared")
            .exec().out == "Hello staticHello shared"
    }

    @ToBeFixedForConfigurationCache

Attributes
    - shared = shared-value
    - unique = jar-value
Artifacts
    - producer-jar.txt

--------------------------------------------------
Variant javadocElements
--------------------------------------------------

Capabilities
    - org.test:producer:1.0 (default capability)
Attributes
    - shared = shared-value
    - unique = javadoc-value
Artifacts

import javax.annotation.concurrent.ThreadSafe;
import java.io.File;
import java.util.Optional;

/**
 * Manages the shared services that are scoped to a particular Gradle user home dir and which can be shared by multiple build invocations. These shared services also include the global services.
 *
 * <p>A plugin can contribute shared services to this scope by providing an implementation of {@link GradleModuleServices}.
 */
@ThreadSafe

│       ├── src
│       │   └──...
│       └── build.gradle    // <3>
├── shared
│   ├── src
│   │   └──...
│   └── build.gradle
└── settings.gradle
----
<1> Create the `MyCustomTask` task.
<2> A shared build script.
<3> Uses the `MyCustomTask` task and shared build script.
=====

In the `buildSrc`, the build script `shared.gradle(.kts)` is created.

import org.junit.ClassRule
import spock.lang.Shared
import spock.lang.Specification

@Requires(UnitTestPreconditions.Symlinks)
@UsesNativeServices
class FileCollectionSymlinkTest extends Specification {
    @Shared Project project = ProjectBuilder.builder().build()
    @Shared @ClassRule TestNameTestDirectoryProvider temporaryFolder = TestNameTestDirectoryProvider.newInstance(getClass())

            if (toolChain in VisualCpp) {
                cCompiler.args "/Zi"
                linker.args "/DEBUG"
            }
        }
    }
}
// end::compiler-args[]

// tag::all-shared-libraries[]
// For any shared library binaries built with Visual C++,
// define the DLL_EXPORT macro
model {
    binaries {
        withType(SharedLibraryBinarySpec) {
            if (toolChain in VisualCpp) {

        given:
        createLock(Exclusive)

        when:
        createLock(Shared)

        then:
        thrown(IllegalStateException)
    }

    def "cannot lock twice in single process for shared mode"() {
        given:
        createLock(Shared)

        when:
        createLock(Shared)

        then:
        thrown(IllegalStateException)
    }

=====

In this example, there are three subprojects called `shared`, `api`, and `person-service`:

1. The `person-service` subproject depends on the other two subprojects, `shared` and `api`.
2. The `api` subproject depends on the `shared` subproject.

We use the `:` separator to define a <<intro_multi_project_builds#sec:project_path,project path>> such as `services:person-service` or `:shared`.

	Shared     = flag.Bool("shared", false, "generate code that can be linked into a shared library")
	Dynlink    = flag.Bool("dynlink", false, "support references to Go symbols defined in other shared libraries")
	Linkshared = flag.Bool("linkshared", false, "generate code that will be linked against Go shared libraries")