lockRankAllg:            "allg",
	lockRankAllp:            "allp",
	lockRankNotifyList:      "notifyList",
	lockRankSudog:           "sudog",
	lockRankTimers:          "timers",
	lockRankTimer:           "timer",
	lockRankNetpollInit:     "netpollInit",
	lockRankRoot:            "root",
	lockRankItab:            "itab",
	lockRankReflectOffs:     "reflectOffs",
	lockRankUserArenaState:  "userArenaState",

		}
		wg.Done()
	}()

	go func() {
		wg.Wait()
		close(done)
	}()

	timer := time.NewTimer(timeout)
	defer timer.Stop()
	select {
	case p := <-plat:
		return p
	case <-done:
		select {
		case p := <-plat:
			return p
		default:
			return &Unknown{}
		}
	case <-timer.C:
		log.Info("timed out waiting for platform detection, treating it as Unknown")
		return &Unknown{}
	}

import org.gradle.configuration.ScriptPlugin;
import org.gradle.configuration.ScriptPluginFactory;
import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.internal.time.Time;
import org.gradle.internal.time.Timer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class BuildScriptProcessor implements ProjectConfigureAction {

func (t *Ticker) Stop() {
	if !t.initTicker {
		// This is misuse, and the same for time.Timer would panic,
		// but this didn't always panic, and we keep it not panicking
		// to avoid breaking old programs. See issue 21874.
		return
	}
	stopTimer((*Timer)(unsafe.Pointer(t)))
}

// Reset stops a ticker and resets its period to the specified duration.

func (b *bufferedBackend) processIncomingEvents(stopCh <-chan struct{}) {
	defer close(b.buffer)

	var (
		maxWaitChan  <-chan time.Time
		maxWaitTimer *time.Timer
	)
	// Only use max wait batching if batching is enabled.
	if b.maxBatchSize > 1 {
		maxWaitTimer = time.NewTimer(b.maxBatchWait)
		maxWaitChan = maxWaitTimer.C
		defer maxWaitTimer.Stop()
	}

	for {
		func() {

import org.gradle.internal.scan.time.BuildScanBuildStartedTime

class BuildScanBuildStartedTimeIntegTest extends AbstractIntegrationSpec {

    def "can access build scan build started time"() {
        when:
        buildFile << """
            def time = project.services.get($BuildScanBuildStartedTime.name).buildStartedTime
            def timer = project.services.get($BuildStartedTime.name)

// adjusts the system-wide timer resolution. Go needs a
// high resolution timer while running and there's little extra cost
// if we're already using the CPU, but if all Ps are idle there's no
// need to consume extra power to drive the high-res timer.
func osRelax(relax bool) uint32 {
	if haveHighResTimer {
		// If the high resolution timer is available, the runtime uses the timer

import org.gradle.internal.operations.BuildOperationExecutor;
import org.gradle.internal.operations.BuildOperationQueue;
import org.gradle.internal.operations.RunnableBuildOperation;
import org.gradle.internal.time.Time;
import org.gradle.internal.time.Timer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.annotation.Nullable;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

	}
	c := &sigctxt{info, ctx}
	gp := sigFetchG(c)
	setg(gp)
	if gp == nil || (gp.m != nil && gp.m.isExtraInC) {
		if sig == _SIGPROF {
			// Some platforms (Linux) have per-thread timers, which we use in
			// combination with the process-wide timer. Avoid double-counting.
			if validSIGPROF(nil, c) {
				sigprofNonGoPC(c.sigpc())
			}
			return
		}
		if sig == sigPreempt && preemptMSupported && debug.asyncpreemptoff == 0 {

import org.gradle.api.internal.specs.ExplainingSpec;
import org.gradle.api.logging.Logger;
import org.gradle.api.logging.Logging;
import org.gradle.internal.id.IdGenerator;
import org.gradle.internal.time.CountdownTimer;
import org.gradle.internal.time.Time;
import org.gradle.launcher.daemon.context.DaemonConnectDetails;
import org.gradle.launcher.daemon.context.DaemonContext;
import org.gradle.launcher.daemon.logging.DaemonMessages;