【Go】通道：缓冲通道和非缓冲通道

通道的基本概念

缓冲通道

非缓冲通道

总结

通道的基本概念

在Go语言中，通道是一种特殊的类型，用于在goroutine之间传递数据。你可以将通道想象为数据的传输管道。通道分为两种类型：

非缓冲通道（Unbuffered Channels）：发送操作会阻塞，直到另一goroutine在对应的通道上执行接收操作，这时候数据才会被发送成功，发送goroutine才能继续执行。
缓冲通道（Buffered Channels）：可以存储一定数量的值，无需立即有goroutine接收这些值。

缓冲通道

缓冲通道通过在make函数中指定第二个参数来创建，这个参数定义了通道可以存储的值的数量。在你提供的代码中，messages是一个缓冲通道，其容量为2：

messages := make(chan string, 2)

这意味着即使没有goroutine准备好接收数据，你也可以往messages通道发送两个字符串。如果尝试发送更多的数据，那么发送操作会阻塞，直到有空间可用。

messages <- "buffered"
messages <- "channel"



fmt.Println(<-messages)
fmt.Println(<-messages)

简单代码：


package main

import "fmt"

func main() {

	// Here we `make` a channel of strings buffering up to
	// 2 values.
	messages := make(chan string, 2)

	// Because this channel is buffered, we can send these
	// values into the channel without a corresponding
	// concurrent receive.
	messages <- "buffered"
	messages <- "channel"

	// Later we can receive these two values as usual.
	fmt.Println(<-messages)
	fmt.Println(<-messages)
}

使用场景

缓冲通道在需要解耦发送者和接收者的速率时非常有用。例如，在一个情况下，可能生产者生成数据的速度快于消费者处理数据的速度，那么一个适当大小的缓冲可以帮助平衡这种速率差异，减少直接阻塞的发生。

这里将展示一个使用缓冲通道的Go程序，该程序模拟一个简单的并行任务处理场景，其中多个工人（goroutine）并发地从一个任务队列（缓冲通道）中获取任务并执行。此示例中，我们将创建一个任务通道和一个结果通道，每个工人都从任务通道接收任务，处理完毕后将结果发送到结果通道。这种方式非常适用于需要任务分发和结果收集的场景。

package main

import (
	"fmt"
	"time"
	"sync"
)

// Task 表示一个简单的任务，这里仅仅是一个数值
type Task int

// Result 表示任务处理的结果，这里包含任务原始值和处理后的信息
type Result struct {
	Task Task
	Info string
}

func worker(id int, tasks <-chan Task, results chan<- Result, wg *sync.WaitGroup) {
	defer wg.Done()
	for task := range tasks {
		fmt.Printf("工人 %d 开始处理任务 %d\n", id, task)
		// 模拟任务处理时间
		time.Sleep(time.Second)
		// 发送结果到结果通道
		results <- Result{Task: task, Info: fmt.Sprintf("工人 %d 完成", id)}
	}
}

func main() {
	// 创建缓冲通道
	tasks := make(chan Task, 10)
	results := make(chan Result, 10)

	// 使用 WaitGroup 来等待所有工人完成
	var wg sync.WaitGroup

	// 启动三个工人 goroutines
	for i := 1; i <= 3; i++ {
		wg.Add(1)
		go worker(i, tasks, results, &wg)
	}

	// 分发任务
	for j := 1; j <= 5; j++ {
		tasks <- Task(j)
	}

	// 关闭任务通道，表示不再有任务被发送
	close(tasks)

	// 等待所有工人完成
	wg.Wait()

	// 关闭结果通道
	close(results)

	// 输出所有处理结果
	for result := range results {
		fmt.Printf("任务 %d: %s\n", result.Task, result.Info)
	}
}

程序说明

任务和结果结构：我们定义了两种类型，Task 和 Result，分别代表任务和处理结果。
工人goroutine：worker 函数是每个工人的行为定义。它持续从任务通道接收任务，处理它们（这里仅模拟为等待1秒），然后将结果发送到结果通道。
主函数中的并发执行：
- 创建并初始化缓冲通道 tasks 和 results。
- 启动3个工人goroutine，每个都在独立的线程中执行。
- 发送5个任务到任务通道。
- 关闭任务通道，告知工人不再有新任务。
- 使用sync.WaitGroup来等待所有工人的任务处理完成。
- 关闭结果通道并打印所有结果。

这个例子展示了如何使用缓冲通道来管理并发任务的分配和结果收集，使得多个工人能够并行处理任务，同时主程序能够等待所有任务完成并最终收集所有的处理结果。这种模式在实际开发中非常有用，尤其是在需要并行处理大量数据或任务的应用场景中。继续努力，不断深化对Go并发编程的理解和应用！

非缓冲通道

Go语言中的非缓冲通道是一种在goroutine之间进行通信的机制，它在发送和接收数据时具有同步的特性。在非缓冲通道上，数据的发送必须有对应的接收操作同时准备好，否则发送操作会阻塞，直到有goroutine来接收数据。同样，如果通道中没有数据，接收操作也会阻塞，直到有数据被发送到通道。这种特性使得非缓冲通道不仅是数据传输的渠道，还是一个同步多个goroutine的强大工具。

基础介绍

非缓冲通道保证了数据传递的即时性，即数据发送后立即被接收。这种即时的数据交换机制意味着每个发送操作都必须有一个对应的接收操作准备接收数据，这种机制在并发编程中常用于控制不同goroutine之间的执行顺序。

下面的示例展示了如何使用非缓冲通道进行两个goroutine之间的同步通信。在这个例子中，我们将创建一个主goroutine和一个工作goroutine，主goroutine发送一个任务到工作goroutine，然后等待工作goroutine的处理结果。

package main

import (
	"fmt"
	"time"
)

func worker(done chan bool) {
	fmt.Println("工作中...")
	time.Sleep(time.Second)
	fmt.Println("工作完成")
	// 发送一个值表示工作已经完成
	done <- true
}

func main() {
	// 创建一个非缓冲的布尔型通道
	done := make(chan bool)

	// 启动一个工作goroutine
	go worker(done)

	// 等待工作goroutine的通知
	<-done
	fmt.Println("在主goroutine中继续执行")
}

程序解析

通道的创建和使用：我们通过make(chan bool)创建了一个非缓冲的布尔型通道done。这个通道用来从工作goroutine向主goroutine发送任务完成的信号。
工作goroutine：worker函数模拟长时间运行的任务，完成后通过done通道发送一个true值来通知主goroutine任务已完成。
主goroutine的阻塞等待：在主goroutine中，使用<-done来阻塞主goroutine的执行，直到从done通道接收到工作完成的信号。

总结

非缓冲通道是Go语言中一种实现goroutine间同步通信的强大机制。通过确保每个发送操作都必须有一个对应的接收操作同时准备好，非缓冲通道可以精确控制数据的即时传递和goroutine的执行顺序。这种通道不仅是数据传输的渠道，也是协调并发操作的关键工具。通过非缓冲通道，Go程序能够以直接且同步的方式处理并发任务，从而保持高效和可靠的执行流程。简而言之，非缓冲通道是Go并发编程中不可或缺的同步神器

缓冲通道在Go语言中是一种允许在没有接收方准备好时进行数据传输的通信机制。这种通道通过内部缓冲区来暂存数据，从而允许发送操作在缓冲区未满时立即返回，而不必等待接收方。缓冲通道的存在极大地提升了并发程序的灵活性和效率，使得goroutine之间可以更加灵活地进行非阻塞通信和数据交换。

Thomas_Lbw