Question

除运行时自动调度外，某些时候需要手动控制任务执行。

挂起

暂时挂起任务，释放线程去执行其他任务。
当前任务被放回任务队列，等待下次被某个线程重新获取后继续执行。

也就是说，一个任务不一定由同一线程完成。实际上，除了主动协作调度外，还要考虑运行时抢占调度等因素。长时间运行的任务会被暂停，让其他等待任务有机会执行，以确保公平。

package main

import (
	"sync"
	"runtime"
)

func main() {
    
    // 限制并发任务数。
	runtime.GOMAXPROCS(1)

	var wg sync.WaitGroup
	wg.Add(2)

	a, b := make(chan struct{}), make(chan struct{})

	go func() {
		defer wg.Done()

		<- a
		for i := 0; i < 5; i++ {
			println("a", i)
		}
	}()

	go func() {
		defer wg.Done()

		<- b
		for i := 0; i < 5; i++ {
			println("b", i)
			if i == 2 { runtime.Gosched() }
		}
	}()

    // 安排执行次序。
    close(b)
    close(a)
    
	wg.Wait()
}

/* --- output -----------
b 0
b 1
b 2  <---- PAUSE
a 0
a 1
a 2
a 3
a 4
b 3  <---- CONT
b 4
*/

发令

暂停一批任务，直到某个信号发出。

func main() {
	var wg sync.WaitGroup
	r := make(chan struct{})
    
	for i := 0; i < 10; i++ {
		wg.Add(1)

		go func(id int){
			defer wg.Done()

			<- r            // 阻塞，等待信号。
			println(id)
		}(i)
	}
    
    close(r)
	wg.Wait()
}

也可反向使用 sync.WaitGroup ，让多个 goroutine Wait ，然后 main Done 。
类似实现，还有信号量，可以控制启动任务数量。

次序

多个任务按特定次序执行。

func main() {
	const CNT = 5

    var wg sync.WaitGroup
	wg.Add(CNT)

	var chans [CNT]chan struct{}
    
	for i := 0; i < CNT; i++ {
		chans[i] = make(chan struct{})

		go func(id int){
			defer wg.Done()
			<- chans[id]
			println(id)
		}(i)
	}

	// 次序（延时，给调度器时间处理）
	for _, x := range []int{4, 0, 1, 3, 2} {
		close(chans[x])
		time.Sleep(time.Millisecond * 10)
	}

	wg.Wait()
}