// responsibility to ensure that all other threads using a ThreadLocal
// have exited when it dies, or the per-thread objects for those
// threads will not be deleted.
//
// Google Test only uses global ThreadLocal objects.  That means they
// will die after main() has returned.  Therefore, no per-thread
// object managed by Google Test will be leaked as long as all threads
// using Google Test have exited when main() returns.

// CGO_ENABLED=0 or 1. Note, there is an extended copy of this same
// test in ../../misc/cgo/test/issue1435.go which requires
// CGO_ENABLED=1 and launches pthreads from C that run concurrently
// with the Go code of the test - and the test validates that these
// pthreads are also kept in sync with the security state changed with
// the syscalls. Care should be taken to mirror any enhancements to
// this test here in that file too.

/**
 * Implementations must allow concurrent reading and writing, so that a thread can read and a thread can write at the same time.
 * Implementations do not need to support multiple read threads or multiple write threads.
 */
public interface StatefulSerializer<T> {
    /**
     * Should not perform any buffering
     */
    ObjectReader<T> newReader(Decoder decoder);

    /**

        extension.reportsDir == project.file("build/reports/pmd")
        !extension.ignoreFailures
        extension.maxFailures.get() == 0
        extension.rulesMinimumPriority.get() == 5
        extension.threads.get() == 1
    }

    def "configures pmd task for each source set"() {
        project.pluginManager.apply(JavaBasePlugin)
        project.sourceSets {
            main
            test
            other

    }

    def 'can stop from multiple threads'() {
        when:
        dispatch.dispatchTo(target1)

        parallel.start {
            dispatch.stop()
        }
        parallel.start {
            dispatch.stop()
        }

        then:
        noExceptionThrown()
    }

    def 'can request stop from multiple threads'() {
        when:
        dispatch.dispatchTo(target1)

import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.infra.Blackhole;

import static org.gradle.internal.deprecation.DeprecationMessageBuilder.createDefaultDeprecationId;

@SuppressWarnings("Since15")
@Threads(2)
@Warmup(iterations = 5)
@Measurement(iterations = 5)
@State(Scope.Benchmark)

     *
     * No synchronization is applied to the target, so this method may be called for a given target concurrently by multiple threads.
     * Other threads may also be doing work with the target when this method is called.
     * This method is responsible for any synchronization required to create the model.
     */
    Object create(BuildState target);

   * This is useful if the given service uses daemon threads, and we want to keep the JVM from
   * exiting immediately on shutdown, instead giving these daemon threads a chance to terminate
   * normally.
   *
   * @param service ExecutorService which uses daemon threads
   * @param terminationTimeout how long to wait for the executor to finish before terminating the
   *     JVM

	// into (0,period].
	//
	// Otherwise, this would show up as a bias away from short-lived threads and
	// from threads that are only occasionally active: for example, when the
	// garbage collector runs on a mostly-idle system, the additional threads it
	// activates may do a couple milliseconds of GC-related work and nothing
	// else in the few seconds that the profiler observes.

 * giving the classloader a chance to rewrite the bytecode of the class.
 * <p>
 * Methods defined in this interface may be called concurrently in multiple threads.
 */
public interface InstrumentingClassLoader {
    /**
     * This hook is called when the class is being defined in this classloader.