Golang协程中channel和sync的角色扮演分析

更新时间：2026年01月04日 09:17:39 作者：魏码不凡

文章介绍了Go语言中的channel和sync包的作用,详细说明了它们在协程通信、同步与协调以及避免共享状态方面的重要性,感兴趣的朋友跟随小编一起看看吧

Channel

channel 是Go语言中用于协程（goroutine）之间通信的一种机制。通过channel，你可以在不同的goroutine之间安全地传递数据。

代码示例

package main
import (
	"fmt"
	"strconv"
	"time"
)
func main() {
	fmt.Println("主进程开始")
	done := make(chan bool, 5)
	for i := 0; i < 5; i++ {
		fmt.Println("等待进协程:" + strconv.Itoa(i))
		go worker(i, done)
	}
	for i := 0; i < 5; i++ {
		fmt.Println("等待出协程:" + strconv.Itoa(i))
		<-done
		fmt.Println("已经出协程:" + strconv.Itoa(i))
	}
	close(done)
	fmt.Println("主进程结束")
}
func worker(i int, done chan bool) {
	time.Sleep(2 * time.Second)
	fmt.Println("协程:" + strconv.Itoa(i))
	done <- true
}

Golang缓冲channel和非缓冲channel的区别说明

Sync

sync 包提供了基本的同步原语，用于在多个goroutine之间协调对共享资源的访问。

代码示例

package main
import (
    "fmt"
    "strconv"
    "sync"
    "time"
)
func main() {
    fmt.Println("主进程开始")
    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        fmt.Println("等待进协程:" + strconv.Itoa(i))
        wg.Add(1)
        go worker(i, &wg)
    }
    fmt.Println("主进程等待")
    wg.Wait()
    fmt.Println("主进程结束")
}
func worker(i int, wg *sync.WaitGroup) {
    defer wg.Done()
    time.Sleep(2 * time.Second)
    fmt.Println("协程:" + strconv.Itoa(i))
}

实际应用

问题代码

package main
import (
	"fmt"
	"sync"
)
// 定义结构体
type MyStruct struct {
	Field1 string
	Field2 int
}
func main() {
	var myStructs []MyStruct
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		fmt.Println(i)
		go worker(&myStructs, &wg, i)
	}
	wg.Wait()
	fmt.Println(myStructs)
	fmt.Println(len(myStructs))
}
func worker(data *[]MyStruct, wg *sync.WaitGroup, i int) {
	defer wg.Done()
	ss := MyStruct{
		Field1: fmt.Sprintf("Data %d", i),
		Field2: i * 10,
	}
	*data = append(*data, ss)
}

问题分析

多个 worker 协程并发地向共享切片 myStructs 添加元素时存在竞态风险。由于 Go 语言的切片并非并发安全，当多个协程同时调用 append 函数修改切片时，可能导致数据竞争或意外行为。

解决方案

Mutex（互斥锁）解决案例

Golang语言中的互斥锁和读写锁（Mutex和RWMutex）

package main
import (
    "fmt"
    "sync"
)
// 定义结构体
type MyStruct struct {
    Field1 string
    Field2 int
}
func main() {
    var myStructs []MyStruct
    var mu sync.Mutex
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go worker(&myStructs, &wg, &mu, i)
    }
    wg.Wait()
    fmt.Println(myStructs)
    fmt.Println(len(myStructs))
}
func worker(data *[]MyStruct, wg *sync.WaitGroup, mu *sync.Mutex, i int) {
    defer wg.Done()
    ss := MyStruct{
        Field1: fmt.Sprintf("Data %d", i),
        Field2: i * 10,
    }
    mu.Lock()
    *data = append(*data, ss)
    mu.Unlock()
}

问题虽已解决，但Mutex在高并发场景下会导致大量锁等待，对系统性能造成显著影响。

Channel 解决案例

package main
import (
	"fmt"
	"sync"
)
type MyStruct struct {
	Field1 string
	Field2 int
}
func main() {
	var wg sync.WaitGroup
	dataChan := make(chan MyStruct, 10)
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go worker(dataChan, &wg, i)
	}
	go func() {
		wg.Wait()
		close(dataChan)
	}()
	var myStructs []MyStruct
	for ss := range dataChan {
		myStructs = append(myStructs, ss)
	}
	fmt.Println(myStructs)
	fmt.Println(len(myStructs))
}
func worker(dataChan chan<- MyStruct, wg *sync.WaitGroup, i int) {
	defer wg.Done()
	ss := MyStruct{
		Field1: fmt.Sprintf("Data %d", i),
		Field2: i * 10,
	}
	dataChan <- ss
}

结论

Channel 的角色

channel是Go语言中协程（goroutine）之间通信的桥梁，它有以下重要作用：

协程间通信：channel提供了一种在goroutine之间安全地传递数据的方式。通过使用channel，goroutine可以相互发送和接收数据，从而实现协作和协调。
同步与协调：channel的阻塞特性使得goroutine之间的同步变得简单而直观。当一个goroutine试图从一个没有数据的channel中接收数据时，它会阻塞直到有数据可用。同样，当一个goroutine试图向一个已经满的channel发送数据时，它也会被阻塞。这种阻塞机制使得goroutine能够按照预期的顺序进行通信和协作。
避免共享状态：通过使用channel进行通信，可以减少对共享状态的依赖，从而降低并发编程中的复杂性和错误率。每个goroutine可以拥有自己的局部变量和状态，并通过channel与其他goroutine进行交互，而无需直接访问共享内存。

Sync 的角色

sync包提供了一组同步原语，用于保护共享资源和协调goroutine的执行，确保并发程序的正确性和一致性。sync包中的关键组件包括：

互斥锁（Mutex）：sync.Mutex是一个互斥锁，用于保护共享资源，确保同一时间只有一个goroutine可以访问该资源。通过加锁和解锁操作，可以防止多个goroutine同时修改共享资源，从而避免竞态条件和数据不一致。
读写锁（RWMutex）：sync.RWMutex是互斥锁的一种扩展，允许多个goroutine同时读取共享资源，但在写入时阻塞所有其他goroutine（无论是读还是写）。这种读写分离的机制可以提高并发程序的性能，特别是在读多写少的场景中。
等待组（WaitGroup）：sync.WaitGroup提供了一种等待一组goroutine完成的方法。通过调用Add方法增加等待组的计数，并在每个goroutine结束时调用Done方法减少计数，主goroutine可以调用Wait方法阻塞，直到所有goroutine都完成执行。这有助于协调goroutine的执行顺序和依赖关系。
条件变量（Cond）：sync.Cond是一个条件变量，允许一个或多个goroutine等待某个条件为真，并在该条件变为真时通知它们。条件变量提供了一种更灵活的同步机制，适用于需要根据特定条件进行等待和通知的场景。

综上所述，channel和sync包在Go语言的并发编程中各自扮演着重要的角色。channel用于goroutine之间的通信和同步，而sync包提供了保护共享资源和协调goroutine执行的同步原语。它们共同确保了并发程序的正确性和高效性。

到此这篇关于Golang协程中channel和sync的角色扮演分析的文章就介绍到这了,更多相关go协程channel和sync内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

golang利用pprof与go-torch如何做性能分析
这篇文章主要给大家介绍了关于golang利用pprof与go-torch如何做性能分析的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2018-07-07
Go语言中的多种测试方法
本文主要介绍了Go语言中的多种测试方法,包括单元测试、表格驱动测试、基准测试等,文中通过示例代码介绍的非常详细,需要的朋友们下面随着小编来一起学习学习吧
2025-07-07
一文掌握go的sync.RWMutex锁
这篇文章主要介绍了一文掌握go的sync.RWMutex锁,本文是为了在面试中能快速口述RW锁，并非为了完整解答RW锁的机制，需要的朋友可以参考下
2023-03-03
go build -tags的其他用法命令详解
go build -tags和go install -tags中的-tags 参数功能完全一致（都是通过标签控制编译哪些代码）,核心区别在于 go build 和 go install 这两个命令本身的行为差异,而非 -tags的用法,本文介绍go build -tags的其他用法,感兴趣的朋友跟随小编一起看看吧
2025-10-10
使用golang生成prometheus格式数据
Prometheus是一个开源的监控系统,拥有许多Advanced Feature,本文将介绍Primetheus client的使用,并基于golang生成prometheus格式数据,希望对大家有所帮助
2025-02-02
Go每日一库之quicktemplate的使用
quicktemplate快速、功能强大、易于使用的Go模板引擎。比html/模板快20倍，本文我们就详细的介绍一下quicktemplate的具体使用，感兴趣的可以了解一下
2021-07-07
详解Go 结构体格式化输出
这篇文章主要介绍了Go 结构体格式化输出的相关资料，帮助大家更好的理解和学习go语言，感兴趣的朋友可以了解下
2020-08-08
Golang中map的三种声明定义方式实现
本文主要介绍了Golang中map的三种声明定义方式实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-02-02
Go语言实现布谷鸟过滤器的方法
这篇文章主要介绍了Go语言实现布谷鸟过滤器的方法,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2021-03-03
利用go语言实现查找二叉树中的最大宽度
这篇文章主要介绍了利用go语言实现查找二叉树中的最大宽度，文章围绕主题展开详细介绍，具有一定的参考价值，需要的小伙伴可以参考一下
2022-05-05