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内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Go语言打包优化之减小二进制文件体积的多种方法
这篇文章主要介绍了Go语言打包优化之减小二进制文件体积的多种方法,Go语言提供了许多工具和技巧来帮助我们进行代码优化,文中通过代码介绍的非常详细,需要的朋友可以参考下
2025-05-05
go语言实现简单http服务的方法
这篇文章主要介绍了go语言实现简单http服务的方法,涉及Go语言http操作技巧,具有一定参考借鉴价值,需要的朋友可以参考下
2015-02-02
docker如何安装部署golang应用程序
这篇文章主要为大家介绍了docker如何安装部署golang应用程序详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
2023-11-11
Go中JSON解析时tag的使用
本文主要介绍了Go中JSON解析时tag的使用，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2022-01-01
使用Go语言实现一个简单的词频分析系统
在数据分析和文本挖掘中,词频统计（Word Frequency Analysis）是最基础也是最常用的技术之一,本文将带你用 Go 语言实现一个简易的词频分析系统,感兴趣的小伙伴可以了解下
2025-09-09
使用GO实现Paxos共识算法的方法
这篇文章主要介绍了使用GO实现Paxos共识算法,本文给大家介绍的非常详细，对大家的学习或工作，具有一定的参考借鉴价值，需要的朋友可以参考下
2020-09-09
Go实现List、Set、Stack、Deque等数据结构的操作方法
Go语言团队的一个核心目标是保持语言的简单性,他们认为,如果一个功能可以用简单的组合来实现,那就没有必要把它放进标准库里,本文给大家介绍Go实现List、Set、Stack、Deque等数据结构的操作方法,感兴趣的朋友跟随小编一起看看吧
2024-12-12
Go语言中的值类型与引用类型的使用
Go语言中的数据类型可以分为值类型和引用类型,值类型包括基本和复合数据类型,特点是在传递时进行复制,保证数据的安全性,引用类型如slice、map等,传递的是引用副本,便于大型数据操作且提高性能,理解这些概念有助于编写更高效、安全的Go代码
2024-09-09
在Golang中使用C语言代码实例
这篇文章主要介绍了在Golang中使用C语言代码实例,本文先是给出了一个Hello World例子、Golang 引用 C例子,并总结了一些要注意的地方,需要的朋友可以参考下
2014-10-10
使用Go语言解析动态JSON格式的方法
本篇文章主要介绍了使用Go语言解析动态JSON格式的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-12-12