- Go 教程系列笔记 Interface 第一部分
- Go 教程系列笔记 Interface 第二部分
- Go 教程系列笔记 并发介绍
- Go 教程系列笔记 goroutine（协程）
- Go 教程系列笔记 Channel 通道
- Go 教程系列笔记 缓冲通道和工作池
- Go 教程系列笔记 Select
- Go 教程系列笔记 Mutex（互斥锁）
- Go 教程系列笔记 结构而不是类-Go中的OOP
- Go 教程系列笔记 组合而不是继承-Go 中的 OOP
- Go 教程系列笔记 多态-Go 中的 OOP
我们在上一个教程中讨论的所有通道基本上都是无缓冲的。正如我们在通道教程中详细讨论的那样，发送和接收无缓冲的通道都是阻塞的。
可以创建带缓冲区的通道。仅当缓冲区已满时才会阻塞对缓冲通道的发送。类似地，仅当缓冲区为空才阻塞从缓冲通道接收。
可以通过将额外的容量参数传递给 make 指定缓冲区大小的函数来创建缓冲通道。
ch := make(chan type, capacity)对于具有缓冲区的通道，上述语法中的容量应大于0。默认情况下，无缓冲通道的容量为0。
<!-- more -->
让我们写一些代码并创建一个缓冲的通道。
package main
import (
"fmt"
)
func main() {
ch := make(chan string, 2)
ch <- "naveen"
ch <- "paul"
fmt.Println(<- ch)
fmt.Println(<- ch)
}另一个例子
package main
import (
"fmt"
"time"
)
func write(ch chan int) {
for i := 0; i < 5; i++ {
ch <- i
fmt.Println("successfully wrote", i, "to ch")
}
close(ch)
}
func main() {
ch := make(chan int, 2)
go write(ch)
time.Sleep(2 * time.Second)
for v := range ch {
fmt.Println("read value", v,"from ch")
time.Sleep(2 * time.Second)
}
}代码中的方法 close(ch) 是将通道关闭（写），这样在 for range 会收到结束的信息。
Deadlock 死锁
func main() {
ch := make(chan string, 2)
ch <- "naveen"
ch <- "paul"
ch <- "steve"
fmt.Println(<-ch)
fmt.Println(<-ch)
}在上面的程序中，ch 的写入容量是2的缓冲通道。当写入第三个时，由于通道已超过其容量，因此写入被阻塞，现在一些 goroutine 必须从通道读取以便继续写入，但在这种情况下，没有从该通道同时读取。因此会出现死锁，程序会在运行时出现以下信息：
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
/tmp/sandbox274756028/main.go:11 +0x100长度与容量
缓冲通道的容量是通道可以容纳的值的数量。这是我们使用 make 函数创建缓冲通道时指定的值。
缓冲通道的长度是当前在其中存在的元素数。
func main() {
ch := make(chan string, 3)
ch <- "naveen"
ch <- "paul"
fmt.Println("capacity is", cap(ch)) //3
fmt.Println("length is", len(ch)) //2
fmt.Println("read value", <-ch)
fmt.Println("new length is", len(ch)) //1
}WaitGroup
本教程的下一部分是关于 Worker Pools。要了解工作池，我们首先需要了解WaitGroup它在工作池的使用。
让我们停止理论并立即编写一些代码????
package main
import (
"fmt"
"sync"
"time"
)
func process(i int, wg *sync.WaitGroup) {
fmt.Println("started Goroutine ", i)
time.Sleep(2 * time.Second)
fmt.Printf("Goroutine %d ended\n", i)
wg.Done()
}
func main() {
no := 3
var wg sync.WaitGroup
for i := 0; i < no; i++ {
wg.Add(1)
go process(i, &wg)
}
wg.Wait()
fmt.Println("All go routines finished executing")
}WaitGroup 是一种结构类型。WaitGroup 有三个方法Add，Done，Wait，分别是增加一个，完成一个，等待全部完成。
Worker Pool 实现
缓冲通道的一个重要用途是实现工作池。
通常，工作池是一组线程，它们正在等待分配给它们的任务。一旦完成分配的任务，它们就会再次为下一个任务提供服务。
以下是工作池的核心功能：
- 创建一个 goroutine 池，它监听输入缓冲的通道，等待分配工作
- 向输入缓冲通道添加工作
- 工作完成后，将结果写入输出缓冲通道
- 从输出缓冲通道读取和打印结果
完整的程序：
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
type Job struct {
id int
randomno int
}
type Result struct {
job Job
sumofdigits int
}
var jobs = make(chan Job, 10)
var results = make(chan Result, 10)
func digits(number int) int {
sum := 0
no := number
for no != 0 {
digit := no % 10
sum += digit
no /= 10
}
time.Sleep(2 * time.Second)
return sum
}
func worker(wg *sync.WaitGroup) {
for job := range jobs {
output := Result{job, digits(job.randomno)}
results <- output
}
wg.Done()
}
func createWorkerPool(noOfWorkers int) {
var wg sync.WaitGroup
for i := 0; i < noOfWorkers; i++ {
wg.Add(1)
go worker(&wg)
}
wg.Wait()
close(results)
}
func allocate(noOfJobs int) {
for i := 0; i < noOfJobs; i++ {
randomno := rand.Intn(999)
job := Job{i, randomno}
jobs <- job
}
close(jobs)
}
func result(done chan bool) {
for result := range results {
fmt.Printf("Job id %d, input random no %d , sum of digits %d\n", result.job.id, result.job.randomno, result.sumofdigits)
}
done <- true
}
func main() {
startTime := time.Now()
noOfJobs := 100
go allocate(noOfJobs)
done := make(chan bool)
go result(done)
noOfWorkers := 10
createWorkerPool(noOfWorkers)
<-done
endTime := time.Now()
diff := endTime.Sub(startTime)
fmt.Println("total time taken ", diff.Seconds(), "seconds")
}有疑问加站长微信联系（非本文作者）
