1. 无缓冲 Channels 概述
在 Golang 中，Channel 是一种结构，用于在不同的 Goroutine 之间传递数据。Channel 可以是带缓冲的或者无缓冲的，其中无缓冲的 Channel 是指长度为 0 的 Channel。在无缓冲的 Channel 中，如果某个 Goroutine 向 Channel 写入数据，它会一直阻塞直到该 Channel 有另外一个 Goroutine 从中读取数据为止。同样地，如果某个 Goroutine 从无缓冲的 Channel 中读取数据，它会一直阻塞直到该 Channel 有另外一个 Goroutine 向其中写入数据为止。
1.1 无缓冲 Channels 的优点
无缓冲的 Channel 与带缓冲的 Channel 相比，具有以下优点：
可以避免数据的竞态条件
可以使 Goroutine 的执行顺序更加一致，从而使程序更加可控
可以减少内存的使用
1.2 无缓冲 Channels 示例
下面是一个简单的示例程序，展示了如何使用无缓冲的 Channel 进行数据的传递：
package main
import "fmt"
func main() {
ch := make(chan int)
go func() {
x := 10
fmt.Println("Sending:", x)
ch <- x
}()
fmt.Println("Receiving:", <- ch)
}
在上面的示例程序中，我们先创建了一个无缓冲的 Channel，然后在一个新的 Goroutine 中向该 Channel 中写入了一个整数 10。在主 Goroutine 中，我们从该 Channel 中读取了数据，并将其打印出来。
运行上面的代码，我们可以看到以下输出：
Sending: 10
Receiving: 10
从输出结果中可以看出，无缓冲的 Channel 很好地达到了我们想要的目的。具体来说，先执行了发送操作，然后阻塞直到接收操作被执行。
2. 无缓冲 Channels 的顺序同步
无缓冲的 Channel 不仅可以用于数据的传递，还可以用于 Goroutine 的同步。具体来说，通过 Channel 的阻塞操作，我们可以让多个 Goroutine 按照特定的顺序执行。
2.1. 确定顺序
在使用无缓冲的 Channel 进行顺序同步之前，我们需要确定各个 Goroutine 的执行顺序。下面是一个简单的示例，展示了如何让三个 Goroutine 按照顺序执行：
package main
import "fmt"
func main() {
done := make(chan bool)
go func() {
fmt.Println("First")
done <- true
}()
<- done
go func() {
fmt.Println("Second")
done <- true
}()
<- done
fmt.Println("Third")
}
在上面的示例程序中，我们首先创建了一个 Channel，然后启动了三个 Goroutine。
第一个 Goroutine 打印了 "First"，然后向 Channel 中发送一个布尔类型的值，表示它已经完成了工作。在主 Goroutine 中，我们从该 Channel 中读取了一个布尔类型的值，表示第一个 Goroutine 已经完成了工作。
接下来，我们启动第二个 Goroutine。该 Goroutine 打印了 "Second"，然后向 Channel 中发送一个布尔类型的值，表示它已经完成了工作。在主 Goroutine 中，我们从该 Channel 中读取了一个布尔类型的值，表示第二个 Goroutine 已经完成了工作。
最后，我们打印了 "Third"，表示第三个 Goroutine 已经完成了工作。
运行上述代码，输出结果如下：
First
Second
Third
从输出结果可以看出，上述代码是按顺序执行的，即第一个 Goroutine 先执行完，接着第二个 Goroutine 执行完，最后才执行第三个 Goroutine。
2.2. 限制并发数
无缓冲的 Channel 不仅可以用于按顺序执行 Goroutine，还可以用于限制并发数。具体来说，我们可以使用一个无缓冲的 Channel 充当信号量，限制在某个时刻同时执行的 Goroutine 数量，从而实现并发控制。下面是一个简单的示例程序，展示了如何使用无缓冲的 Channel 限制并发数为 2：
package main
import (
"fmt"
"sync"
)
func main() {
maxConcurrency := 2
sem := make(chan bool, maxConcurrency)
wg := sync.WaitGroup{}
wg.Add(5)
for i := 0; i < 5; i++ {
sem <- true
go func(i int) {
fmt.Printf("Start %d\n", i)
defer func() {
<-sem
wg.Done()
}()
// do some work
}(i)
}
wg.Wait()
}
在上面的示例程序中，我们首先创建了一个长度为 2 的 Channel，并使用 sync.WaitGroup 来等待所有的 Goroutine 执行完成。
接着，我们使用一个 for 循环开始启动 5 个 Goroutine。在每次启动 Goroutine 之前，我们首先从信号量中获取一个元素，表示还可以有另外一个 Goroutine 开始执行。然后，我们启动一个 Goroutine，执行一些工作，最后释放信号量，表示该 Goroutine 已经完成了工作。
运行上述代码，输出结果如下：
Start 0
Start 1
Start 2
Start 3
Start 4
从输出结果可以看出，上述代码限制了同时执行的 Goroutine 数量不超过 2 个，因此它们是按照顺序依次执行的。这个特性非常适用于并发控制中，例如对 API 请求进行限流等。
总结
本文介绍了 Golang 中如何使用无缓冲 Channels 进行顺序同步，以及如何使用无缓冲的 Channel 限制并发数。无缓冲的 Channel 可以很好地避免数据竞态条件，使 Goroutine 的执行顺序更加一致，从而使程序更加可控。通过 Channel 的阻塞操作，我们可以让多个 Goroutine 按照特定的顺序执行，限制并发数。