var wg sync.WaitGroup
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			var buf [1]byte
			r.ReadAt(buf[:], int64(i))
		}(i)
	}
	wg.Wait()
}

func TestEmptyReaderConcurrent(t *testing.T) {
	// Test for the race detector, to verify a Read that doesn't yield any bytes
	// is okay to use from multiple goroutines. This was our historic behavior.

pkg syscall (windows-386), const USAGE_MATCH_TYPE_OR = 1
pkg syscall (windows-386), const WAIT_ABANDONED = 128
pkg syscall (windows-386), const WAIT_FAILED = 4294967295
pkg syscall (windows-386), const WAIT_OBJECT_0 = 0
pkg syscall (windows-386), const WAIT_TIMEOUT = 258
pkg syscall (windows-386), const WSADESCRIPTION_LEN = 256
pkg syscall (windows-386), const WSASYS_STATUS_LEN = 128

immediately, yielding the element type's <a href="#The_zero_value">zero value</a>
after any previously sent values have been received.
</p>

<pre>
v1 := &lt;-ch
v2 = &lt;-ch
f(&lt;-ch)
&lt;-strobe  // wait until clock pulse and discard received value
</pre>

<p>
A receive expression used in an <a href="#Assignment_statements">assignment statement</a> or initialization of the special form
</p>

<pre>

		return 0, err
	}

	// In case we're booting a device or emulator alongside all.bash, wait for
	// it to be ready. adb wait-for-device is not enough, we have to
	// wait for sys.boot_completed.
	if err := adb("wait-for-device", "exec-out", "while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;"); err != nil {
		return 0, err
	}

	// Done once per make.bash.

	var stderr bytes.Buffer
	cmd.Stderr = &stderr
	if err := cmd.Start(); err != nil {
		return nil, fmt.Errorf("idevicedebugserverproxy: %v", err)
	}
	go func() {
		if err := cmd.Wait(); err != nil {
			if _, ok := err.(*exec.ExitError); ok {
				errChan <- fmt.Errorf("idevicedebugserverproxy: %s", stderr.Bytes())
			} else {
				errChan <- fmt.Errorf("idevicedebugserverproxy: %v", err)
			}
		}

	for i, context := range contexts {
		i, context := i, context
		wg.Add(1)
		go func() {
			defer wg.Done()
			walkers[i] = NewWalker(context, filepath.Join(testenv.GOROOT(t), "src"))
		}()
	}
	wg.Wait()

	var featureCtx = make(map[string]map[string]bool) // feature -> context name -> true
	for _, w := range walkers {
		for _, name := range w.stdPackages {
			pkg, err := w.import_(name)

including <a href="/pkg/sync/#Cond">condition variables</a>,
<a href="/pkg/sync/#Map">lock-free maps</a>,
<a href="/pkg/sync/#Pool">allocation pools</a>,
and
<a href="/pkg/sync/#WaitGroup">wait groups</a>.
The documentation for each of these specifies the guarantees it
makes concerning synchronization.
</p>

<p>
Other packages that provide synchronization abstractions

pkg syscall (linux-arm-cgo), const SYS_EPOLL_CREATE1 ideal-int
pkg syscall (linux-arm-cgo), const SYS_EPOLL_CTL ideal-int
pkg syscall (linux-arm-cgo), const SYS_EPOLL_PWAIT ideal-int
pkg syscall (linux-arm-cgo), const SYS_EPOLL_WAIT ideal-int
pkg syscall (linux-arm-cgo), const SYS_EVENTFD ideal-int
pkg syscall (linux-arm-cgo), const SYS_EVENTFD2 ideal-int
pkg syscall (linux-arm-cgo), const SYS_EXECVE ideal-int